LinearMath (JavaCPP Presets for Bullet Physics SDK 3.25-1.5.11 API)

java.lang.Object
- org.bytedeco.bullet.presets.LinearMath
- - org.bytedeco.bullet.global.LinearMath

All Implemented Interfaces:: InfoMapper

public class LinearMath
extends LinearMath

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`ANGULAR_MOTION_THRESHOLD`
`static int`	`BT_ARRAY_CODE`
`static int`	`BT_BOXSHAPE_CODE`
`static int`	`BT_BULLET_VERSION`
`static int`	`BT_COLLISIONOBJECT_CODE`
`static int`	`BT_CONSTRAINT_CODE`
`static int`	`BT_CONTACTMANIFOLD_CODE`
`static int`	`BT_DNA_CODE`
`static int`	`BT_DYNAMICSWORLD_CODE`
`static double`	`BT_HALF`
`static int`	`BT_HEADER_LENGTH`
`static double`	`BT_LARGE_FLOAT` The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision.
`static int`	`BT_MB_LINKCOLLIDER_CODE`
`static int`	`BT_MULTIBODY_CODE`
`static int`	`BT_NO_PROFILE`
`static double`	`BT_ONE`
`static int`	`BT_QUANTIZED_BVH_CODE`
`static int`	`BT_RIGIDBODY_CODE`
`static int`	`BT_SBMATERIAL_CODE`
`static int`	`BT_SBNODE_CODE`
`static int`	`BT_SERIALIZE_CONTACT_MANIFOLDS` enum btSerializationFlags
`static int`	`BT_SERIALIZE_NO_BVH` enum btSerializationFlags
`static int`	`BT_SERIALIZE_NO_DUPLICATE_ASSERT` enum btSerializationFlags
`static int`	`BT_SERIALIZE_NO_TRIANGLEINFOMAP` enum btSerializationFlags
`static int`	`BT_SHAPE_CODE`
`static int`	`BT_SOFTBODY_CODE`
`static int`	`BT_TRIANLGE_INFO_MAP`
`static double`	`BT_TWO`
`static int`	`BT_USE_PLACEMENT_NEW` 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
`static double`	`BT_ZERO`
`static String`	`btQuaternionDataName`
`static String`	`btVector3DataName` align a pointer to the provided alignment, upwards
`static int`	`QE_FAIL` enum HullError
`static int`	`QE_OK` enum HullError
`static int`	`QF_DEFAULT` enum HullFlag
`static int`	`QF_REVERSE_ORDER` enum HullFlag
`static int`	`QF_TRIANGLES` enum HullFlag
`static double`	`SIMD_2_PI`
`static double`	`SIMD_DEGS_PER_RAD`
`static double`	`SIMD_HALF_PI`
`static double`	`SIMD_PI`
`static double`	`SIMD_RADS_PER_DEG`
`static double`	`SIMDSQRT12`
`static int`	`USE_BT_CLOCK` Real-Time Hierarchical Profiling for Game Programming Gems 3 by Greg Hjelstrom & Byon Garrabrant

Constructor Summary

Constructors
Constructor and Description

LinearMath()

Constructors
Constructor and Description
`LinearMath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static btMatrix3x3`	`add(btMatrix3x3 m1, btMatrix3x3 m2)`
`static btVector3`	`add(btVector3 v1, btVector3 v2)` \brief Return the sum of two vectors (Point symantics)
`static double`	`ANGULAR_MOTION_THRESHOLD()`
`static int`	`BT_ARRAY_CODE()`
`static int`	`BT_BOXSHAPE_CODE()`
`static int`	`BT_COLLISIONOBJECT_CODE()`
`static int`	`BT_CONSTRAINT_CODE()`
`static int`	`BT_CONTACTMANIFOLD_CODE()`
`static int`	`BT_DNA_CODE()`
`static int`	`BT_DYNAMICSWORLD_CODE()`
`static int`	`BT_HASH_NULL()`
`static int`	`BT_MAX_THREAD_COUNT()` These spatial algebra classes are used for btMultiBody, /**see BulletDynamics/Featherstone
`static int`	`BT_MB_LINKCOLLIDER_CODE()`
`static int`	`BT_MULTIBODY_CODE()`
`static int`	`BT_QUANTIZED_BVH_CODE()`
`static int`	`BT_QUICKPROF_MAX_THREAD_COUNT()`
`static int`	`BT_RIGIDBODY_CODE()`
`static int`	`BT_SBMATERIAL_CODE()`
`static int`	`BT_SBNODE_CODE()`
`static int`	`BT_SHAPE_CODE()`
`static int`	`BT_SOFTBODY_CODE()`
`static int`	`BT_TRIANLGE_INFO_MAP()`
`static btVector3`	`btAabbSupport(btVector3 halfExtents, btVector3 supportDir)`
`static double`	`btAcos(double x)`
`static Pointer`	`btAlignedAllocInternal(long size, int alignment)` BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system for regression tests to detect memory leaks #define BT_DEBUG_MEMORY_ALLOCATIONS 1
`static void`	`btAlignedAllocSetCustom(btAllocFunc allocFunc, btFreeFunc freeFunc)` The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom
`static void`	`btAlignedAllocSetCustomAligned(btAlignedAllocFunc allocFunc, btAlignedFreeFunc freeFunc)` If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used.
`static void`	`btAlignedFreeInternal(Pointer ptr)`
`static double`	`btAngle(btQuaternion q1, btQuaternion q2)` \brief Return the angle between two quaternions
`static double`	`btAngle(btVector3 v1, btVector3 v2)` \brief Return the angle between two vectors
`static double`	`btAsin(double x)`
`static double`	`btAtan(double x)`
`static double`	`btAtan2(double x, double y)`
`static double`	`btAtan2Fast(double y, double x)`
`static double`	`btCos(double x)`
`static btITaskScheduler`	`btCreateDefaultTaskScheduler()`
`static btVector3`	`btCross(btVector3 v1, btVector3 v2)` \brief Return the cross product of two vectors
`static double`	`btDegrees(double x)`
`static double`	`btDistance(btVector3 v1, btVector3 v2)` \brief Return the distance between two vectors
`static double`	`btDistance2(btVector3 v1, btVector3 v2)` \brief Return the distance squared between two vectors
`static double`	`btDot(btVector3 v1, btVector3 v2)` \brief Return the dot product between two vectors
`static boolean`	`btEqual(double a, double eps)`
`static double`	`btExp(double x)`
`static double`	`btFabs(double x)`
`static double`	`btFmod(double x, double y)`
`static double`	`btFsel(double a, double b, double c)`
`static boolean`	`btFuzzyZero(double x)`
`static btEnterProfileZoneFunc`	`btGetCurrentEnterProfileZoneFunc()`
`static btLeaveProfileZoneFunc`	`btGetCurrentLeaveProfileZoneFunc()`
`static int`	`btGetCurrentThreadIndex()`
`static btITaskScheduler`	`btGetOpenMPTaskScheduler()`
`static btITaskScheduler`	`btGetPPLTaskScheduler()`
`static btITaskScheduler`	`btGetSequentialTaskScheduler()`
`static btITaskScheduler`	`btGetTaskScheduler()`
`static btITaskScheduler`	`btGetTBBTaskScheduler()`
`static int`	`btGetVersion()`
`static boolean`	`btGreaterEqual(double a, double eps)`
`static int`	`btIsDoublePrecision()`
`static boolean`	`btIsMainThread()`
`static int`	`btIsNegative(double x)`
`static double`	`btLargeDot(double[] a, double[] b, int n)`
`static double`	`btLargeDot(DoubleBuffer a, DoubleBuffer b, int n)`
`static double`	`btLargeDot(DoublePointer a, DoublePointer b, int n)`
`static double`	`btLog(double x)`
`static boolean`	`btMachineIsLittleEndian()`
`static void`	`btMutexLock(btSpinMutex mutex)`
`static boolean`	`btMutexTryLock(btSpinMutex mutex)`
`static void`	`btMutexUnlock(btSpinMutex mutex)`
`static double`	`btNormalizeAngle(double angleInRadians)`
`static void`	`btParallelFor(int iBegin, int iEnd, int grainSize, btIParallelForBody body)`
`static double`	`btParallelSum(int iBegin, int iEnd, int grainSize, btIParallelSumBody body)`
`static double`	`btPow(double x, double y)`
`static int`	`btQuickprofGetCurrentThreadIndex2()`
`static double`	`btRadians(double x)`
`static void`	`btResetThreadIndexCounter()`
`static float`	`btSelect(int condition, float valueIfConditionNonZero, float valueIfConditionZero)`
`static int`	`btSelect(int condition, int valueIfConditionNonZero, int valueIfConditionZero)` btSelect avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 Thanks Phil Knight.
`static void`	`btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc enterFunc)`
`static void`	`btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc leaveFunc)`
`static void`	`btSetTaskScheduler(btITaskScheduler ts)`
`static double`	`btSin(double x)`
`static double`	`btSqrt(double x)`
`static int`	`btStrLen(BytePointer str)`
`static int`	`btStrLen(String str)`
`static int`	`btSwapEndian(int val)`
`static short`	`btSwapEndian(short val)`
`static void`	`btSwapEndianDouble(double d, byte[] dst)`
`static void`	`btSwapEndianDouble(double d, ByteBuffer dst)`
`static void`	`btSwapEndianDouble(double d, BytePointer dst)`
`static int`	`btSwapEndianFloat(float d)` 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.
`static void`	`btSwapScalarEndian(double sourceVal, double[] destVal)`
`static void`	`btSwapScalarEndian(double sourceVal, DoubleBuffer destVal)`
`static void`	`btSwapScalarEndian(double sourceVal, DoublePointer destVal)` btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
`static void`	`btSwapVector3Endian(btVector3 sourceVec, btVector3 destVec)` btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
`static double`	`btTan(double x)`
`static boolean`	`btThreadsAreRunning()`
`static double`	`btTriple(btVector3 v1, btVector3 v2, btVector3 v3)`
`static double`	`btUnswapEndianDouble(byte[] src)`
`static double`	`btUnswapEndianDouble(ByteBuffer src)`
`static double`	`btUnswapEndianDouble(BytePointer src)`
`static float`	`btUnswapEndianFloat(int a)`
`static void`	`btUnSwapVector3Endian(btVector3 vector)` btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
`static btVector3`	`divide(btVector3 v1, btVector3 v2)` \brief Return the vector inversely scaled by s
`static btVector3`	`divide(btVector3 v, double s)` \brief Return the vector inversely scaled by s
`static double`	`dot(btQuaternion q1, btQuaternion q2)` \brief Calculate the dot product between two quaternions
`static boolean`	`equals(btMatrix3x3 m1, btMatrix3x3 m2)` \brief Equality operator between two matrices It will test all elements are equal.
`static boolean`	`equals(btTransform t1, btTransform t2)` \brief Test if two transforms have all elements equal
`static btQuaternion`	`inverse(btQuaternion q)` \brief Return the inverse of a quaternion
`static double`	`length(btQuaternion q)` \brief Return the length of a quaternion
`static btVector3`	`lerp(btVector3 v1, btVector3 v2, double t)` \brief Return the linear interpolation between two vectors
`static btMatrix3x3`	`multiply(btMatrix3x3 m1, btMatrix3x3 m2)`
`static btVector3`	`multiply(btMatrix3x3 m, btVector3 v)`
`static btMatrix3x3`	`multiply(btMatrix3x3 m, double k)`
`static btQuaternion`	`multiply(btQuaternion q1, btQuaternion q2)` \brief Return the product of two quaternions
`static btQuaternion`	`multiply(btQuaternion q, btVector3 w)`
`static btVector3`	`multiply(btVector3 v, btMatrix3x3 m)`
`static btQuaternion`	`multiply(btVector3 w, btQuaternion q)`
`static btVector3`	`multiply(btVector3 v1, btVector3 v2)` \brief Return the elementwise product of two vectors
`static btVector3`	`multiply(btVector3 v, double s)` \brief Return the vector scaled by s
`static btVector3`	`multiply(double s, btVector3 v)` \brief Return the vector scaled by s
`static btVector3`	`quatRotate(btQuaternion rotation, btVector3 v)`
`static int`	`sBulletDNAlen()`
`static void`	`sBulletDNAlen(int setter)`
`static int`	`sBulletDNAlen64()`
`static void`	`sBulletDNAlen64(int setter)`
`static BytePointer`	`sBulletDNAstr()`
`static byte`	`sBulletDNAstr(int i)`
`static void`	`sBulletDNAstr(int i, byte setter)`
`static BytePointer`	`sBulletDNAstr64()`
`static byte`	`sBulletDNAstr64(int i)`
`static void`	`sBulletDNAstr64(int i, byte setter)`
`static void`	`setElem(btMatrixXd mat, int row, int col, double val)` original version written by Erwin Coumans, October 2013
`static void`	`setElem(btMatrixXf mat, int row, int col, float val)`
`static btQuaternion`	`shortestArcQuat(btVector3 v0, btVector3 v1)`
`static btQuaternion`	`shortestArcQuatNormalize2(btVector3 v0, btVector3 v1)`
`static double`	`SIMD_2_PI()`
`static double`	`SIMD_DEGS_PER_RAD()`
`static double`	`SIMD_HALF_PI()`
`static double`	`SIMD_PI()`
`static double`	`SIMD_RADS_PER_DEG()`
`static double`	`SIMDSQRT12()`
`static btQuaternion`	`slerp(btQuaternion q1, btQuaternion q2, double t)` \brief Return the result of spherical linear interpolation betwen two quaternions
`static btMatrix3x3`	`subtract(btMatrix3x3 m1, btMatrix3x3 m2)`
`static btVector3`	`subtract(btVector3 v)` \brief Return the negative of the vector
`static btVector3`	`subtract(btVector3 v1, btVector3 v2)` \brief Return the difference between two vectors

Methods inherited from class org.bytedeco.bullet.presets.LinearMath
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- BT_BULLET_VERSION
```
public static final int BT_BULLET_VERSION
```
  See Also:
  
  Constant Field Values
- BT_LARGE_FLOAT
```
public static final double BT_LARGE_FLOAT
```
  The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision.
  
  See Also:
  
  Constant Field Values
- SIMD_PI
```
public static final double SIMD_PI
```
- SIMD_2_PI
```
public static final double SIMD_2_PI
```
- SIMD_HALF_PI
```
public static final double SIMD_HALF_PI
```
- SIMD_RADS_PER_DEG
```
public static final double SIMD_RADS_PER_DEG
```
- SIMD_DEGS_PER_RAD
```
public static final double SIMD_DEGS_PER_RAD
```
- SIMDSQRT12
```
public static final double SIMDSQRT12
```
- BT_ONE
```
public static final double BT_ONE
```
  See Also:
  
  Constant Field Values
- BT_ZERO
```
public static final double BT_ZERO
```
  See Also:
  
  Constant Field Values
- BT_TWO
```
public static final double BT_TWO
```
  See Also:
  
  Constant Field Values
- BT_HALF
```
public static final double BT_HALF
```
  See Also:
  
  Constant Field Values
- btVector3DataName
```
public static final String btVector3DataName
```
  align a pointer to the provided alignment, upwards
  
  See Also:
  
  Constant Field Values
- btQuaternionDataName
```
public static final String btQuaternionDataName
```
  See Also:
  
  Constant Field Values
- BT_USE_PLACEMENT_NEW
```
public static final int BT_USE_PLACEMENT_NEW
```
  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
  
  See Also:
  
  Constant Field Values
- BT_SERIALIZE_NO_BVH
```
public static final int BT_SERIALIZE_NO_BVH
```
  enum btSerializationFlags
  
  See Also:
  
  Constant Field Values
- BT_SERIALIZE_NO_TRIANGLEINFOMAP
```
public static final int BT_SERIALIZE_NO_TRIANGLEINFOMAP
```
  enum btSerializationFlags
  
  See Also:
  
  Constant Field Values
- BT_SERIALIZE_NO_DUPLICATE_ASSERT
```
public static final int BT_SERIALIZE_NO_DUPLICATE_ASSERT
```
  enum btSerializationFlags
  
  See Also:
  
  Constant Field Values
- BT_SERIALIZE_CONTACT_MANIFOLDS
```
public static final int BT_SERIALIZE_CONTACT_MANIFOLDS
```
  enum btSerializationFlags
  
  See Also:
  
  Constant Field Values
- BT_HEADER_LENGTH
```
public static final int BT_HEADER_LENGTH
```
  See Also:
  
  Constant Field Values
- BT_MULTIBODY_CODE
```
public static final int BT_MULTIBODY_CODE
```
- BT_MB_LINKCOLLIDER_CODE
```
public static final int BT_MB_LINKCOLLIDER_CODE
```
- BT_SOFTBODY_CODE
```
public static final int BT_SOFTBODY_CODE
```
- BT_COLLISIONOBJECT_CODE
```
public static final int BT_COLLISIONOBJECT_CODE
```
- BT_RIGIDBODY_CODE
```
public static final int BT_RIGIDBODY_CODE
```
- BT_CONSTRAINT_CODE
```
public static final int BT_CONSTRAINT_CODE
```
- BT_BOXSHAPE_CODE
```
public static final int BT_BOXSHAPE_CODE
```
- BT_QUANTIZED_BVH_CODE
```
public static final int BT_QUANTIZED_BVH_CODE
```
- BT_TRIANLGE_INFO_MAP
```
public static final int BT_TRIANLGE_INFO_MAP
```
- BT_SHAPE_CODE
```
public static final int BT_SHAPE_CODE
```
- BT_ARRAY_CODE
```
public static final int BT_ARRAY_CODE
```
- BT_SBMATERIAL_CODE
```
public static final int BT_SBMATERIAL_CODE
```
- BT_SBNODE_CODE
```
public static final int BT_SBNODE_CODE
```
- BT_DYNAMICSWORLD_CODE
```
public static final int BT_DYNAMICSWORLD_CODE
```
- BT_CONTACTMANIFOLD_CODE
```
public static final int BT_CONTACTMANIFOLD_CODE
```
- BT_DNA_CODE
```
public static final int BT_DNA_CODE
```
- USE_BT_CLOCK
```
public static final int USE_BT_CLOCK
```
  Real-Time Hierarchical Profiling for Game Programming Gems 3 by Greg Hjelstrom & Byon Garrabrant
  
  See Also:
  
  Constant Field Values
- BT_NO_PROFILE
```
public static final int BT_NO_PROFILE
```
  See Also:
  
  Constant Field Values
- QF_TRIANGLES
```
public static final int QF_TRIANGLES
```
  enum HullFlag
  
  See Also:
  
  Constant Field Values
- QF_REVERSE_ORDER
```
public static final int QF_REVERSE_ORDER
```
  enum HullFlag
  
  See Also:
  
  Constant Field Values
- QF_DEFAULT
```
public static final int QF_DEFAULT
```
  enum HullFlag
  
  See Also:
  
  Constant Field Values
- QE_OK
```
public static final int QE_OK
```
  enum HullError
  
  See Also:
  
  Constant Field Values
- QE_FAIL
```
public static final int QE_FAIL
```
  enum HullError
  
  See Also:
  
  Constant Field Values
- ANGULAR_MOTION_THRESHOLD
```
public static final double ANGULAR_MOTION_THRESHOLD
```

Constructor Detail
- LinearMath
```
public LinearMath()
```

Method Detail

btGetVersion
```
public static int btGetVersion()
```

btIsDoublePrecision

public static int btIsDoublePrecision()

btSqrt

@Cast(value="btScalar")
public static double btSqrt(@Cast(value="btScalar")
                                                    double x)

btFabs

@Cast(value="btScalar")
public static double btFabs(@Cast(value="btScalar")
                                                    double x)

btCos

@Cast(value="btScalar")
public static double btCos(@Cast(value="btScalar")
                                                   double x)

btSin

@Cast(value="btScalar")
public static double btSin(@Cast(value="btScalar")
                                                   double x)

btTan

@Cast(value="btScalar")
public static double btTan(@Cast(value="btScalar")
                                                   double x)

btAcos

@Cast(value="btScalar")
public static double btAcos(@Cast(value="btScalar")
                                                    double x)

btAsin

@Cast(value="btScalar")
public static double btAsin(@Cast(value="btScalar")
                                                    double x)

btAtan

@Cast(value="btScalar")
public static double btAtan(@Cast(value="btScalar")
                                                    double x)

btAtan2

@Cast(value="btScalar")
public static double btAtan2(@Cast(value="btScalar")
                                                     double x,
                                                     @Cast(value="btScalar")
                                                     double y)

btExp

@Cast(value="btScalar")
public static double btExp(@Cast(value="btScalar")
                                                   double x)

btLog

@Cast(value="btScalar")
public static double btLog(@Cast(value="btScalar")
                                                   double x)

btPow

@Cast(value="btScalar")
public static double btPow(@Cast(value="btScalar")
                                                   double x,
                                                   @Cast(value="btScalar")
                                                   double y)

btFmod

@Cast(value="btScalar")
public static double btFmod(@Cast(value="btScalar")
                                                    double x,
                                                    @Cast(value="btScalar")
                                                    double y)

SIMD_PI

@MemberGetter
public static double SIMD_PI()

SIMD_2_PI

@MemberGetter
public static double SIMD_2_PI()

SIMD_HALF_PI

@MemberGetter
public static double SIMD_HALF_PI()

SIMD_RADS_PER_DEG

@MemberGetter
public static double SIMD_RADS_PER_DEG()

SIMD_DEGS_PER_RAD

@MemberGetter
public static double SIMD_DEGS_PER_RAD()

SIMDSQRT12

@MemberGetter
public static double SIMDSQRT12()

btAtan2Fast

@Cast(value="btScalar")
public static double btAtan2Fast(@Cast(value="btScalar")
                                                         double y,
                                                         @Cast(value="btScalar")
                                                         double x)

btFuzzyZero

@Cast(value="bool")
public static boolean btFuzzyZero(@Cast(value="btScalar")
                                                      double x)

btEqual

@Cast(value="bool")
public static boolean btEqual(@Cast(value="btScalar")
                                                  double a,
                                                  @Cast(value="btScalar")
                                                  double eps)

btGreaterEqual

@Cast(value="bool")
public static boolean btGreaterEqual(@Cast(value="btScalar")
                                                         double a,
                                                         @Cast(value="btScalar")
                                                         double eps)

btIsNegative

public static int btIsNegative(@Cast(value="btScalar")
                               double x)

btRadians

@Cast(value="btScalar")
public static double btRadians(@Cast(value="btScalar")
                                                       double x)

btDegrees

@Cast(value="btScalar")
public static double btDegrees(@Cast(value="btScalar")
                                                       double x)

btFsel

@Cast(value="btScalar")
public static double btFsel(@Cast(value="btScalar")
                                                    double a,
                                                    @Cast(value="btScalar")
                                                    double b,
                                                    @Cast(value="btScalar")
                                                    double c)

btMachineIsLittleEndian

@Cast(value="bool")
public static boolean btMachineIsLittleEndian()

btSelect

@Cast(value="unsigned")
public static int btSelect(@Cast(value="unsigned")
                                                   int condition,
                                                   @Cast(value="unsigned")
                                                   int valueIfConditionNonZero,
                                                   @Cast(value="unsigned")
                                                   int valueIfConditionZero)

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

btSelect

public static float btSelect(@Cast(value="unsigned")
                             int condition,
                             float valueIfConditionNonZero,
                             float valueIfConditionZero)

btSwapEndian

@Cast(value="unsigned")
public static int btSwapEndian(@Cast(value="unsigned")
                                                       int val)

btSwapEndian

@Cast(value="unsigned short")
public static short btSwapEndian(@Cast(value="unsigned short")
                                                               short val)

btSwapEndianFloat
```
@Cast(value="unsigned int")
public static int btSwapEndianFloat(float d)
```
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

btUnswapEndianFloat

public static float btUnswapEndianFloat(@Cast(value="unsigned int")
                                        int a)

btSwapEndianDouble

public static void btSwapEndianDouble(double d,
                                      @Cast(value="unsigned char*")
                                      BytePointer dst)

btSwapEndianDouble

public static void btSwapEndianDouble(double d,
                                      @Cast(value="unsigned char*")
                                      ByteBuffer dst)

btSwapEndianDouble

public static void btSwapEndianDouble(double d,
                                      @Cast(value="unsigned char*")
                                      byte[] dst)

btUnswapEndianDouble

public static double btUnswapEndianDouble(@Cast(value="const unsigned char*")
                                          BytePointer src)

btUnswapEndianDouble

public static double btUnswapEndianDouble(@Cast(value="const unsigned char*")
                                          ByteBuffer src)

btUnswapEndianDouble

public static double btUnswapEndianDouble(@Cast(value="const unsigned char*")
                                          byte[] src)

btLargeDot

@Cast(value="btScalar")
public static double btLargeDot(@Cast(value="const btScalar*")
                                                        DoublePointer a,
                                                        @Cast(value="const btScalar*")
                                                        DoublePointer b,
                                                        int n)

btLargeDot

@Cast(value="btScalar")
public static double btLargeDot(@Cast(value="const btScalar*")
                                                        DoubleBuffer a,
                                                        @Cast(value="const btScalar*")
                                                        DoubleBuffer b,
                                                        int n)

btLargeDot

@Cast(value="btScalar")
public static double btLargeDot(@Cast(value="const btScalar*")
                                                        double[] a,
                                                        @Cast(value="const btScalar*")
                                                        double[] b,
                                                        int n)

btNormalizeAngle

@Cast(value="btScalar")
public static double btNormalizeAngle(@Cast(value="btScalar")
                                                              double angleInRadians)

add

@ByVal
 @Name(value="operator +")
public static btVector3 add(@Const @ByRef
                                                              btVector3 v1,
                                                              @Const @ByRef
                                                              btVector3 v2)

\brief Return the sum of two vectors (Point symantics)

multiply

@ByVal
 @Name(value="operator *")
public static btVector3 multiply(@Const @ByRef
                                                                   btVector3 v1,
                                                                   @Const @ByRef
                                                                   btVector3 v2)

\brief Return the elementwise product of two vectors

subtract

@ByVal
 @Name(value="operator -")
public static btVector3 subtract(@Const @ByRef
                                                                   btVector3 v1,
                                                                   @Const @ByRef
                                                                   btVector3 v2)

\brief Return the difference between two vectors

subtract

@ByVal
 @Name(value="operator -")
public static btVector3 subtract(@Const @ByRef
                                                                   btVector3 v)

\brief Return the negative of the vector

multiply

@ByVal
 @Name(value="operator *")
public static btVector3 multiply(@Const @ByRef
                                                                   btVector3 v,
                                                                   @Cast(value="const btScalar")
                                                                   double s)

\brief Return the vector scaled by s

multiply

@ByVal
 @Name(value="operator *")
public static btVector3 multiply(@Cast(value="const btScalar")
                                                                   double s,
                                                                   @Const @ByRef
                                                                   btVector3 v)

\brief Return the vector scaled by s

divide

@ByVal
 @Name(value="operator /")
public static btVector3 divide(@Const @ByRef
                                                                 btVector3 v,
                                                                 @Cast(value="const btScalar")
                                                                 double s)

\brief Return the vector inversely scaled by s

divide

@ByVal
 @Name(value="operator /")
public static btVector3 divide(@Const @ByRef
                                                                 btVector3 v1,
                                                                 @Const @ByRef
                                                                 btVector3 v2)

\brief Return the vector inversely scaled by s

btDot

@Cast(value="btScalar")
public static double btDot(@Const @ByRef
                                                   btVector3 v1,
                                                   @Const @ByRef
                                                   btVector3 v2)

\brief Return the dot product between two vectors

btDistance2

@Cast(value="btScalar")
public static double btDistance2(@Const @ByRef
                                                         btVector3 v1,
                                                         @Const @ByRef
                                                         btVector3 v2)

\brief Return the distance squared between two vectors

btDistance

@Cast(value="btScalar")
public static double btDistance(@Const @ByRef
                                                        btVector3 v1,
                                                        @Const @ByRef
                                                        btVector3 v2)

\brief Return the distance between two vectors

btAngle

@Cast(value="btScalar")
public static double btAngle(@Const @ByRef
                                                     btVector3 v1,
                                                     @Const @ByRef
                                                     btVector3 v2)

\brief Return the angle between two vectors

btCross

@ByVal
public static btVector3 btCross(@Const @ByRef
                                       btVector3 v1,
                                       @Const @ByRef
                                       btVector3 v2)

\brief Return the cross product of two vectors

btTriple

@Cast(value="btScalar")
public static double btTriple(@Const @ByRef
                                                      btVector3 v1,
                                                      @Const @ByRef
                                                      btVector3 v2,
                                                      @Const @ByRef
                                                      btVector3 v3)

lerp

@ByVal
public static btVector3 lerp(@Const @ByRef
                                    btVector3 v1,
                                    @Const @ByRef
                                    btVector3 v2,
                                    @Cast(value="const btScalar")
                                    double t)

\brief Return the linear interpolation between two vectors

Parameters:: v1 - One vector; v2 - The other vector; t - The ration of this to v (t = 0 => return v1, t=1 => return v2)

btSwapScalarEndian

public static void btSwapScalarEndian(@Cast(value="const btScalar")
                                      double sourceVal,
                                      @Cast(value="btScalar*") @ByRef
                                      DoublePointer destVal)

btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization

btSwapScalarEndian

public static void btSwapScalarEndian(@Cast(value="const btScalar")
                                      double sourceVal,
                                      @Cast(value="btScalar*") @ByRef
                                      DoubleBuffer destVal)

btSwapScalarEndian

public static void btSwapScalarEndian(@Cast(value="const btScalar")
                                      double sourceVal,
                                      @Cast(value="btScalar*") @ByRef
                                      double[] destVal)

btSwapVector3Endian

public static void btSwapVector3Endian(@Const @ByRef
                                       btVector3 sourceVec,
                                       @ByRef
                                       btVector3 destVec)

btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization

btUnSwapVector3Endian

public static void btUnSwapVector3Endian(@ByRef
                                         btVector3 vector)

btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization

multiply

@ByVal
 @Name(value="operator *")
public static btQuaternion multiply(@Const @ByRef
                                                                      btQuaternion q1,
                                                                      @Const @ByRef
                                                                      btQuaternion q2)

\brief Return the product of two quaternions

multiply

@ByVal
 @Name(value="operator *")
public static btQuaternion multiply(@Const @ByRef
                                                                      btQuaternion q,
                                                                      @Const @ByRef
                                                                      btVector3 w)

multiply

@ByVal
 @Name(value="operator *")
public static btQuaternion multiply(@Const @ByRef
                                                                      btVector3 w,
                                                                      @Const @ByRef
                                                                      btQuaternion q)

dot

@Cast(value="btScalar")
public static double dot(@Const @ByRef
                                                 btQuaternion q1,
                                                 @Const @ByRef
                                                 btQuaternion q2)

\brief Calculate the dot product between two quaternions

length

@Cast(value="btScalar")
public static double length(@Const @ByRef
                                                    btQuaternion q)

\brief Return the length of a quaternion

btAngle

@Cast(value="btScalar")
public static double btAngle(@Const @ByRef
                                                     btQuaternion q1,
                                                     @Const @ByRef
                                                     btQuaternion q2)

\brief Return the angle between two quaternions

inverse

@ByVal
public static btQuaternion inverse(@Const @ByRef
                                          btQuaternion q)

\brief Return the inverse of a quaternion

slerp

@ByVal
public static btQuaternion slerp(@Const @ByRef
                                        btQuaternion q1,
                                        @Const @ByRef
                                        btQuaternion q2,
                                        @Cast(value="const btScalar")
                                        double t)

\brief Return the result of spherical linear interpolation betwen two quaternions

Parameters:: q1 - The first quaternion; q2 - The second quaternion; t - The ration between q1 and q2. t = 0 return q1, t=1 returns q2 Slerp assumes constant velocity between positions.

quatRotate

@ByVal
public static btVector3 quatRotate(@Const @ByRef
                                          btQuaternion rotation,
                                          @Const @ByRef
                                          btVector3 v)

shortestArcQuat

@ByVal
public static btQuaternion shortestArcQuat(@Const @ByRef
                                                  btVector3 v0,
                                                  @Const @ByRef
                                                  btVector3 v1)

shortestArcQuatNormalize2

@ByVal
public static btQuaternion shortestArcQuatNormalize2(@ByRef
                                                            btVector3 v0,
                                                            @ByRef
                                                            btVector3 v1)

multiply

@ByVal
 @Name(value="operator *")
public static btMatrix3x3 multiply(@Const @ByRef
                                                                     btMatrix3x3 m,
                                                                     @Cast(value="const btScalar")
                                                                     double k)

add

@ByVal
 @Name(value="operator +")
public static btMatrix3x3 add(@Const @ByRef
                                                                btMatrix3x3 m1,
                                                                @Const @ByRef
                                                                btMatrix3x3 m2)

subtract

@ByVal
 @Name(value="operator -")
public static btMatrix3x3 subtract(@Const @ByRef
                                                                     btMatrix3x3 m1,
                                                                     @Const @ByRef
                                                                     btMatrix3x3 m2)

multiply

@ByVal
 @Name(value="operator *")
public static btVector3 multiply(@Const @ByRef
                                                                   btMatrix3x3 m,
                                                                   @Const @ByRef
                                                                   btVector3 v)

multiply

@ByVal
 @Name(value="operator *")
public static btVector3 multiply(@Const @ByRef
                                                                   btVector3 v,
                                                                   @Const @ByRef
                                                                   btMatrix3x3 m)

multiply

@ByVal
 @Name(value="operator *")
public static btMatrix3x3 multiply(@Const @ByRef
                                                                     btMatrix3x3 m1,
                                                                     @Const @ByRef
                                                                     btMatrix3x3 m2)

equals

@Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                             btMatrix3x3 m1,
                                                                             @Const @ByRef
                                                                             btMatrix3x3 m2)

\brief Equality operator between two matrices It will test all elements are equal.

equals

@Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                             btTransform t1,
                                                                             @Const @ByRef
                                                                             btTransform t2)

\brief Test if two transforms have all elements equal

BT_HASH_NULL

@MemberGetter
public static int BT_HASH_NULL()

sBulletDNAstr

@Cast(value="char")
public static byte sBulletDNAstr(int i)

sBulletDNAstr

public static void sBulletDNAstr(int i,
                                 byte setter)

sBulletDNAstr

@MemberGetter
 @Cast(value="char*")
public static BytePointer sBulletDNAstr()

sBulletDNAlen
```
public static int sBulletDNAlen()
```

sBulletDNAlen

public static void sBulletDNAlen(int setter)

sBulletDNAstr64

@Cast(value="char")
public static byte sBulletDNAstr64(int i)

sBulletDNAstr64

public static void sBulletDNAstr64(int i,
                                   byte setter)

sBulletDNAstr64

@MemberGetter
 @Cast(value="char*")
public static BytePointer sBulletDNAstr64()

sBulletDNAlen64
```
public static int sBulletDNAlen64()
```

sBulletDNAlen64

public static void sBulletDNAlen64(int setter)

btStrLen

public static int btStrLen(@Cast(value="const char*")
                           BytePointer str)

btStrLen

public static int btStrLen(String str)

BT_MULTIBODY_CODE

@MemberGetter
public static int BT_MULTIBODY_CODE()

BT_MB_LINKCOLLIDER_CODE

@MemberGetter
public static int BT_MB_LINKCOLLIDER_CODE()

BT_SOFTBODY_CODE

@MemberGetter
public static int BT_SOFTBODY_CODE()

BT_COLLISIONOBJECT_CODE

@MemberGetter
public static int BT_COLLISIONOBJECT_CODE()

BT_RIGIDBODY_CODE

@MemberGetter
public static int BT_RIGIDBODY_CODE()

BT_CONSTRAINT_CODE

@MemberGetter
public static int BT_CONSTRAINT_CODE()

BT_BOXSHAPE_CODE

@MemberGetter
public static int BT_BOXSHAPE_CODE()

BT_QUANTIZED_BVH_CODE

@MemberGetter
public static int BT_QUANTIZED_BVH_CODE()

BT_TRIANLGE_INFO_MAP

@MemberGetter
public static int BT_TRIANLGE_INFO_MAP()

BT_SHAPE_CODE

@MemberGetter
public static int BT_SHAPE_CODE()

BT_ARRAY_CODE

@MemberGetter
public static int BT_ARRAY_CODE()

BT_SBMATERIAL_CODE

@MemberGetter
public static int BT_SBMATERIAL_CODE()

BT_SBNODE_CODE

@MemberGetter
public static int BT_SBNODE_CODE()

BT_DYNAMICSWORLD_CODE

@MemberGetter
public static int BT_DYNAMICSWORLD_CODE()

BT_CONTACTMANIFOLD_CODE

@MemberGetter
public static int BT_CONTACTMANIFOLD_CODE()

BT_DNA_CODE

@MemberGetter
public static int BT_DNA_CODE()

btGetCurrentEnterProfileZoneFunc

public static btEnterProfileZoneFunc btGetCurrentEnterProfileZoneFunc()

btGetCurrentLeaveProfileZoneFunc

public static btLeaveProfileZoneFunc btGetCurrentLeaveProfileZoneFunc()

btSetCustomEnterProfileZoneFunc

public static void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc enterFunc)

btSetCustomLeaveProfileZoneFunc

public static void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc leaveFunc)

BT_QUICKPROF_MAX_THREAD_COUNT

@MemberGetter
 @Cast(value="const unsigned int")
public static int BT_QUICKPROF_MAX_THREAD_COUNT()

btQuickprofGetCurrentThreadIndex2

@Cast(value="unsigned int")
public static int btQuickprofGetCurrentThreadIndex2()

BT_MAX_THREAD_COUNT
```
@MemberGetter
 @Cast(value="const unsigned int")
public static int BT_MAX_THREAD_COUNT()
```
These spatial algebra classes are used for btMultiBody, /**see BulletDynamics/Featherstone

btIsMainThread

@Cast(value="bool")
public static boolean btIsMainThread()

btThreadsAreRunning

@Cast(value="bool")
public static boolean btThreadsAreRunning()

btGetCurrentThreadIndex

@Cast(value="unsigned int")
public static int btGetCurrentThreadIndex()

btResetThreadIndexCounter

public static void btResetThreadIndexCounter()

btMutexLock

public static void btMutexLock(btSpinMutex mutex)

btMutexUnlock

public static void btMutexUnlock(btSpinMutex mutex)

btMutexTryLock

@Cast(value="bool")
public static boolean btMutexTryLock(btSpinMutex mutex)

btSetTaskScheduler

public static void btSetTaskScheduler(btITaskScheduler ts)

btGetTaskScheduler

public static btITaskScheduler btGetTaskScheduler()

btGetSequentialTaskScheduler

public static btITaskScheduler btGetSequentialTaskScheduler()

btCreateDefaultTaskScheduler

public static btITaskScheduler btCreateDefaultTaskScheduler()

btGetOpenMPTaskScheduler

public static btITaskScheduler btGetOpenMPTaskScheduler()

btGetTBBTaskScheduler

public static btITaskScheduler btGetTBBTaskScheduler()

btGetPPLTaskScheduler

public static btITaskScheduler btGetPPLTaskScheduler()

btParallelFor

public static void btParallelFor(int iBegin,
                                 int iEnd,
                                 int grainSize,
                                 @Const @ByRef
                                 btIParallelForBody body)

btParallelSum

@Cast(value="btScalar")
public static double btParallelSum(int iBegin,
                                                           int iEnd,
                                                           int grainSize,
                                                           @Const @ByRef
                                                           btIParallelSumBody body)

btAlignedAllocInternal

public static Pointer btAlignedAllocInternal(@Cast(value="size_t")
                                             long size,
                                             int alignment)

BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system for regression tests to detect memory leaks #define BT_DEBUG_MEMORY_ALLOCATIONS 1

btAlignedFreeInternal

public static void btAlignedFreeInternal(Pointer ptr)

btAlignedAllocSetCustom

public static void btAlignedAllocSetCustom(btAllocFunc allocFunc,
                                           btFreeFunc freeFunc)

The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom

btAlignedAllocSetCustomAligned
```
public static void btAlignedAllocSetCustomAligned(btAlignedAllocFunc allocFunc,
                                                  btAlignedFreeFunc 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.

ANGULAR_MOTION_THRESHOLD

@MemberGetter
public static double ANGULAR_MOTION_THRESHOLD()

btAabbSupport

@ByVal
public static btVector3 btAabbSupport(@Const @ByRef
                                             btVector3 halfExtents,
                                             @Const @ByRef
                                             btVector3 supportDir)

setElem

public static void setElem(@ByRef
                           btMatrixXd mat,
                           int row,
                           int col,
                           double val)

original version written by Erwin Coumans, October 2013

setElem

public static void setElem(@ByRef
                           btMatrixXf mat,
                           int row,
                           int col,
                           float val)

Class LinearMath

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.bullet.presets.LinearMath

Methods inherited from class java.lang.Object

Field Detail

BT_BULLET_VERSION

BT_LARGE_FLOAT

SIMD_PI

SIMD_2_PI

SIMD_HALF_PI

SIMD_RADS_PER_DEG

SIMD_DEGS_PER_RAD

SIMDSQRT12

BT_ONE

BT_ZERO

BT_TWO

BT_HALF

btVector3DataName

btQuaternionDataName

BT_USE_PLACEMENT_NEW

BT_SERIALIZE_NO_BVH

BT_SERIALIZE_NO_TRIANGLEINFOMAP

BT_SERIALIZE_NO_DUPLICATE_ASSERT

BT_SERIALIZE_CONTACT_MANIFOLDS

BT_HEADER_LENGTH

BT_MULTIBODY_CODE

BT_MB_LINKCOLLIDER_CODE

BT_SOFTBODY_CODE

BT_COLLISIONOBJECT_CODE

BT_RIGIDBODY_CODE

BT_CONSTRAINT_CODE

BT_BOXSHAPE_CODE

BT_QUANTIZED_BVH_CODE

BT_TRIANLGE_INFO_MAP

BT_SHAPE_CODE

BT_ARRAY_CODE

BT_SBMATERIAL_CODE

BT_SBNODE_CODE

BT_DYNAMICSWORLD_CODE

BT_CONTACTMANIFOLD_CODE

BT_DNA_CODE

USE_BT_CLOCK

BT_NO_PROFILE

QF_TRIANGLES

QF_REVERSE_ORDER

QF_DEFAULT

QE_OK

QE_FAIL

ANGULAR_MOTION_THRESHOLD

Constructor Detail

LinearMath

Method Detail

btGetVersion

btIsDoublePrecision

btSqrt

btFabs

btCos

btSin

btTan

btAcos

btAsin

btAtan

btAtan2

btExp

btLog

btPow

btFmod

SIMD_PI

SIMD_2_PI

SIMD_HALF_PI

SIMD_RADS_PER_DEG

SIMD_DEGS_PER_RAD

SIMDSQRT12

btAtan2Fast

btFuzzyZero

btEqual

btGreaterEqual

btIsNegative