Bullet3Common (JavaCPP Presets for Bullet Physics SDK 3.25-1.5.10 API)

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

All Implemented Interfaces:: InfoMapper

public class Bullet3Common
extends Bullet3Common

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`B3_2_PI`
`static double`	`B3_ANGULAR_MOTION_THRESHOLD`
`static int`	`B3_BULLET_VERSION`
`static double`	`B3_DEGS_PER_RAD`
`static float`	`B3_EPSILON`
`static double`	`B3_HALF_PI`
`static float`	`B3_INFINITY`
`static float`	`B3_LARGE_FLOAT`
`static double`	`B3_PI`
`static int`	`B3_POOL_HANDLE_TERMINAL_FREE` enum
`static int`	`B3_POOL_HANDLE_TERMINAL_USED` enum
`static double`	`B3_RADS_PER_DEG`
`static double`	`B3_SQRT12`
`static int`	`B3_USE_PLACEMENT_NEW` 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
`static String`	`b3Vector3DataName` align a pointer to the provided alignment, upwards

Constructor Summary

Constructors
Constructor and Description

Bullet3Common()

Constructors
Constructor and Description
`Bullet3Common()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static b3Matrix3x3`	`add(b3Matrix3x3 m1, b3Matrix3x3 m2)`
`static b3Vector3`	`add(b3Vector3 v1, b3Vector3 v2)` \brief Return the sum of two vectors (Point symantics)
`static double`	`B3_2_PI()`
`static double`	`B3_ANGULAR_MOTION_THRESHOLD()`
`static double`	`B3_DEGS_PER_RAD()`
`static float`	`B3_EPSILON()`
`static double`	`B3_HALF_PI()`
`static int`	`B3_HASH_NULL()` Command-line parsing
`static float`	`B3_INFINITY()`
`static float`	`B3_LARGE_FLOAT()` The b3Scalar type abstracts floating point numbers, to easily switch between double and single floating point precision.
`static double`	`B3_PI()`
`static double`	`B3_RADS_PER_DEG()`
`static double`	`B3_SQRT12()`
`static b3Vector3`	`b3AabbSupport(b3Vector3 halfExtents, b3Vector3 supportDir)`
`static b3Matrix3x3`	`b3AbsoluteMat3x3(b3Matrix3x3 mat)`
`static float`	`b3Acos(float x)`
`static float`	`b3Angle(b3Quaternion q1, b3Quaternion q2)` \brief Return the angle between two quaternions
`static float`	`b3Angle(b3Vector3 v1, b3Vector3 v2)` \brief Return the angle between two vectors
`static float`	`b3Asin(float x)`
`static float`	`b3Atan(float x)`
`static float`	`b3Atan2(float x, float y)`
`static float`	`b3Atan2Fast(float y, float x)`
`static int`	`b3AtomicAdd(int[] p, int val)`
`static int`	`b3AtomicAdd(IntBuffer p, int val)`
`static int`	`b3AtomicAdd(IntPointer p, int val)`
`static float`	`b3Cos(float x)`
`static b3Vector3`	`b3Cross(b3Vector3 v1, b3Vector3 v2)` \brief Return the cross product of two vectors
`static float`	`b3Degrees(float x)`
`static float`	`b3Distance(b3Vector3 v1, b3Vector3 v2)` \brief Return the distance between two vectors
`static float`	`b3Distance2(b3Vector3 v1, b3Vector3 v2)` \brief Return the distance squared between two vectors
`static float`	`b3Dot(b3Quaternion q1, b3Quaternion q2)` \brief Calculate the dot product between two quaternions
`static float`	`b3Dot(b3Vector3 v1, b3Vector3 v2)` \brief Return the dot product between two vectors
`static void`	`b3EnterProfileZone(BytePointer name)` 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
`static void`	`b3EnterProfileZone(String name)`
`static boolean`	`b3Equal(float a, float eps)`
`static float`	`b3Exp(float x)`
`static float`	`b3Fabs(float x)`
`static b3Vector3`	`b3FastNormalized3(b3Vector3 v)`
`static float`	`b3Fmod(float x, float y)`
`static float`	`b3Fsel(float a, float b, float c)`
`static boolean`	`b3FuzzyZero(float x)`
`static int`	`b3GetVersion()`
`static boolean`	`b3GreaterEqual(float a, float eps)`
`static b3Quaternion`	`b3Inverse(b3Quaternion q)` \brief Return the inverse of a quaternion
`static boolean`	`b3IsAlmostZero(b3Vector3 v)`
`static int`	`b3IsNegative(float x)`
`static void`	`b3LeaveProfileZone()`
`static float`	`b3Length(b3Quaternion q)` \brief Return the length of a quaternion
`static b3Vector3`	`b3Lerp(b3Vector3 v1, b3Vector3 v2, float t)` \brief Return the linear interpolation between two vectors
`static float`	`b3Log(float x)`
`static boolean`	`b3MachineIsLittleEndian()`
`static b3Int2`	`b3MakeInt2(int x, int y)`
`static b3Int4`	`b3MakeInt4(int x, int y, int z)`
`static b3Int4`	`b3MakeInt4(int x, int y, int z, int w)`
`static b3UnsignedInt4`	`b3MakeUnsignedInt4(int x, int y, int z)`
`static b3UnsignedInt4`	`b3MakeUnsignedInt4(int x, int y, int z, int w)`
`static b3Vector3`	`b3MakeVector3(float x, float y, float z)`
`static b3Vector3`	`b3MakeVector3(float x, float y, float z, float w)`
`static b3Vector4`	`b3MakeVector4(float x, float y, float z, float w)`
`static int`	`b3MaxDot(b3Vector3 vec, b3Vector3 vecArray, int vecLen, float[] dotOut)`
`static int`	`b3MaxDot(b3Vector3 vec, b3Vector3 vecArray, int vecLen, FloatBuffer dotOut)`
`static int`	`b3MaxDot(b3Vector3 vec, b3Vector3 vecArray, int vecLen, FloatPointer dotOut)`
`static b3Vector3`	`b3MaxFloat4(b3Vector3 a, b3Vector3 b)`
`static b3Vector3`	`b3MinFloat4(b3Vector3 a, b3Vector3 b)`
`static float`	`b3NormalizeAngle(float angleInRadians)`
`static b3Vector3`	`b3Normalized(b3Vector3 vec)`
`static void`	`b3OutputErrorMessageVarArgsInternal(BytePointer str)`
`static void`	`b3OutputErrorMessageVarArgsInternal(String str)`
`static void`	`b3OutputPrintfVarArgsInternal(BytePointer str)` Don't use those internal functions directly, use the b3Printf or b3SetCustomPrintfFunc instead (or warning/error version)
`static void`	`b3OutputPrintfVarArgsInternal(String str)`
`static void`	`b3OutputWarningMessageVarArgsInternal(BytePointer str)`
`static void`	`b3OutputWarningMessageVarArgsInternal(String str)`
`static float`	`b3Pow(float x, float y)`
`static b3Matrix3x3`	`b3QuatGetRotationMatrix(b3Quaternion quat)`
`static b3Quaternion`	`b3QuatInverse(b3Quaternion orn)`
`static b3Quaternion`	`b3QuatMul(b3Quaternion rot0, b3Quaternion rot1)`
`static b3Quaternion`	`b3QuatNormalized(b3Quaternion orn)`
`static b3Vector3`	`b3QuatRotate(b3Quaternion rotation, b3Vector3 v)`
`static float`	`b3Radians(float x)`
`static float`	`b3Select(int condition, float valueIfConditionNonZero, float valueIfConditionZero)`
`static int`	`b3Select(int condition, int valueIfConditionNonZero, int valueIfConditionZero)` b3Select avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 Thanks Phil Knight.
`static void`	`b3SetCustomEnterProfileZoneFunc(b3EnterProfileZoneFunc enterFunc)` Set custom profile zone functions (zones can be nested)
`static void`	`b3SetCustomErrorMessageFunc(b3ErrorMessageFunc errorMsgFunc)`
`static void`	`b3SetCustomLeaveProfileZoneFunc(b3LeaveProfileZoneFunc leaveFunc)`
`static void`	`b3SetCustomPrintfFunc(b3PrintfFunc printfFunc)` The developer can route b3Printf output using their own implementation
`static void`	`b3SetCustomWarningMessageFunc(b3WarningMessageFunc warningMsgFunc)`
`static b3Quaternion`	`b3ShortestArcQuat(b3Vector3 v0, b3Vector3 v1)`
`static b3Quaternion`	`b3ShortestArcQuatNormalize2(b3Vector3 v0, b3Vector3 v1)`
`static float`	`b3Sin(float x)`
`static b3Quaternion`	`b3Slerp(b3Quaternion q1, b3Quaternion q2, float t)` \brief Return the result of spherical linear interpolation betwen two quaternions
`static float`	`b3Sqrt(float y)`
`static int`	`b3SwapEndian(int val)`
`static short`	`b3SwapEndian(short val)`
`static void`	`b3SwapEndianDouble(double d, byte[] dst)`
`static void`	`b3SwapEndianDouble(double d, ByteBuffer dst)`
`static void`	`b3SwapEndianDouble(double d, BytePointer dst)`
`static int`	`b3SwapEndianFloat(float d)` 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.
`static void`	`b3SwapScalarEndian(float sourceVal, float[] destVal)`
`static void`	`b3SwapScalarEndian(float sourceVal, FloatBuffer destVal)`
`static void`	`b3SwapScalarEndian(float sourceVal, FloatPointer destVal)` b3SwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
`static void`	`b3SwapVector3Endian(b3Vector3 sourceVec, b3Vector3 destVec)` b3SwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
`static float`	`b3Tan(float x)`
`static b3Vector3`	`b3TransformPoint(b3Vector3 point, b3Vector3 translation, b3Quaternion orientation)`
`static float`	`b3Triple(b3Vector3 v1, b3Vector3 v2, b3Vector3 v3)`
`static double`	`b3UnswapEndianDouble(byte[] src)`
`static double`	`b3UnswapEndianDouble(ByteBuffer src)`
`static double`	`b3UnswapEndianDouble(BytePointer src)`
`static float`	`b3UnswapEndianFloat(int a)`
`static void`	`b3UnSwapVector3Endian(b3Vector3 vector)` b3UnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
`static b3Vector3`	`divide(b3Vector3 v1, b3Vector3 v2)` \brief Return the vector inversely scaled by s
`static b3Vector3`	`divide(b3Vector3 v, float s)` \brief Return the vector inversely scaled by s
`static boolean`	`equals(b3Matrix3x3 m1, b3Matrix3x3 m2)` \brief Equality operator between two matrices It will test all elements are equal.
`static boolean`	`equals(b3Transform t1, b3Transform t2)` \brief Test if two transforms have all elements equal
`static b3Vector3`	`mtMul3(b3Vector3 a, b3Matrix3x3 b)`
`static b3Matrix3x3`	`multiply(b3Matrix3x3 m1, b3Matrix3x3 m2)`
`static b3Vector3`	`multiply(b3Matrix3x3 m, b3Vector3 v)`
`static b3Matrix3x3`	`multiply(b3Matrix3x3 m, float k)`
`static b3Quaternion`	`multiply(b3Quaternion q1, b3Quaternion q2)` \brief Return the product of two quaternions
`static b3Quaternion`	`multiply(b3Quaternion q, b3Vector3 w)`
`static b3Vector3`	`multiply(b3Vector3 v, b3Matrix3x3 m)`
`static b3Quaternion`	`multiply(b3Vector3 w, b3Quaternion q)`
`static b3Vector3`	`multiply(b3Vector3 v1, b3Vector3 v2)` \brief Return the elementwise product of two vectors
`static b3Vector3`	`multiply(b3Vector3 v, float s)` \brief Return the vector scaled by s
`static b3Vector3`	`multiply(float s, b3Vector3 v)` \brief Return the vector scaled by s
`static b3Matrix3x3`	`subtract(b3Matrix3x3 m1, b3Matrix3x3 m2)`
`static b3Vector3`	`subtract(b3Vector3 v)` \brief Return the negative of the vector
`static b3Vector3`	`subtract(b3Vector3 v1, b3Vector3 v2)` \brief Return the difference between two vectors

Methods inherited from class org.bytedeco.bullet.presets.Bullet3Common
map, mapArrays

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

Field Detail
- B3_USE_PLACEMENT_NEW
```
public static final int B3_USE_PLACEMENT_NEW
```
  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
  
  See Also:
  
  Constant Field Values
- B3_BULLET_VERSION
```
public static final int B3_BULLET_VERSION
```
  See Also:
  
  Constant Field Values
- B3_LARGE_FLOAT
```
public static final float B3_LARGE_FLOAT
```
- B3_2_PI
```
public static final double B3_2_PI
```
- B3_PI
```
public static final double B3_PI
```
- B3_HALF_PI
```
public static final double B3_HALF_PI
```
- B3_RADS_PER_DEG
```
public static final double B3_RADS_PER_DEG
```
- B3_DEGS_PER_RAD
```
public static final double B3_DEGS_PER_RAD
```
- B3_SQRT12
```
public static final double B3_SQRT12
```
- B3_EPSILON
```
public static final float B3_EPSILON
```
- B3_INFINITY
```
public static final float B3_INFINITY
```
- b3Vector3DataName
```
public static final String b3Vector3DataName
```
  align a pointer to the provided alignment, upwards
  
  See Also:
  
  Constant Field Values
- B3_POOL_HANDLE_TERMINAL_FREE
```
public static final int B3_POOL_HANDLE_TERMINAL_FREE
```
  enum
  
  See Also:
  
  Constant Field Values
- B3_POOL_HANDLE_TERMINAL_USED
```
public static final int B3_POOL_HANDLE_TERMINAL_USED
```
  enum
  
  See Also:
  
  Constant Field Values
- B3_ANGULAR_MOTION_THRESHOLD
```
public static final double B3_ANGULAR_MOTION_THRESHOLD
```

Constructor Detail
- Bullet3Common
```
public Bullet3Common()
```

Method Detail

B3_HASH_NULL

@MemberGetter
public static int B3_HASH_NULL()

Command-line parsing

b3EnterProfileZone
```
public static void b3EnterProfileZone(@Cast(value="const char*")
                                      BytePointer name)
```
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

b3EnterProfileZone

public static void b3EnterProfileZone(String name)

b3LeaveProfileZone

public static void b3LeaveProfileZone()

b3SetCustomPrintfFunc
```
public static void b3SetCustomPrintfFunc(b3PrintfFunc printfFunc)
```
The developer can route b3Printf output using their own implementation

b3SetCustomWarningMessageFunc

public static void b3SetCustomWarningMessageFunc(b3WarningMessageFunc warningMsgFunc)

b3SetCustomErrorMessageFunc

public static void b3SetCustomErrorMessageFunc(b3ErrorMessageFunc errorMsgFunc)

b3SetCustomEnterProfileZoneFunc

public static void b3SetCustomEnterProfileZoneFunc(b3EnterProfileZoneFunc enterFunc)

Set custom profile zone functions (zones can be nested)

b3SetCustomLeaveProfileZoneFunc

public static void b3SetCustomLeaveProfileZoneFunc(b3LeaveProfileZoneFunc leaveFunc)

b3OutputPrintfVarArgsInternal

public static void b3OutputPrintfVarArgsInternal(@Cast(value="const char*")
                                                 BytePointer str)

Don't use those internal functions directly, use the b3Printf or b3SetCustomPrintfFunc instead (or warning/error version)

b3OutputPrintfVarArgsInternal

public static void b3OutputPrintfVarArgsInternal(String str)

b3OutputWarningMessageVarArgsInternal

public static void b3OutputWarningMessageVarArgsInternal(@Cast(value="const char*")
                                                         BytePointer str)

b3OutputWarningMessageVarArgsInternal

public static void b3OutputWarningMessageVarArgsInternal(String str)

b3OutputErrorMessageVarArgsInternal

public static void b3OutputErrorMessageVarArgsInternal(@Cast(value="const char*")
                                                       BytePointer str)

b3OutputErrorMessageVarArgsInternal

public static void b3OutputErrorMessageVarArgsInternal(String str)

b3GetVersion
```
public static int b3GetVersion()
```

B3_LARGE_FLOAT
```
@MemberGetter
public static float B3_LARGE_FLOAT()
```
The b3Scalar type abstracts floating point numbers, to easily switch between double and single floating point precision.

b3Sqrt

@Cast(value="b3Scalar")
public static float b3Sqrt(@Cast(value="b3Scalar")
                                                   float y)

b3Fabs

@Cast(value="b3Scalar")
public static float b3Fabs(@Cast(value="b3Scalar")
                                                   float x)

b3Cos

@Cast(value="b3Scalar")
public static float b3Cos(@Cast(value="b3Scalar")
                                                  float x)

b3Sin

@Cast(value="b3Scalar")
public static float b3Sin(@Cast(value="b3Scalar")
                                                  float x)

b3Tan

@Cast(value="b3Scalar")
public static float b3Tan(@Cast(value="b3Scalar")
                                                  float x)

b3Acos

@Cast(value="b3Scalar")
public static float b3Acos(@Cast(value="b3Scalar")
                                                   float x)

b3Asin

@Cast(value="b3Scalar")
public static float b3Asin(@Cast(value="b3Scalar")
                                                   float x)

b3Atan

@Cast(value="b3Scalar")
public static float b3Atan(@Cast(value="b3Scalar")
                                                   float x)

b3Atan2

@Cast(value="b3Scalar")
public static float b3Atan2(@Cast(value="b3Scalar")
                                                    float x,
                                                    @Cast(value="b3Scalar")
                                                    float y)

b3Exp

@Cast(value="b3Scalar")
public static float b3Exp(@Cast(value="b3Scalar")
                                                  float x)

b3Log

@Cast(value="b3Scalar")
public static float b3Log(@Cast(value="b3Scalar")
                                                  float x)

b3Pow

@Cast(value="b3Scalar")
public static float b3Pow(@Cast(value="b3Scalar")
                                                  float x,
                                                  @Cast(value="b3Scalar")
                                                  float y)

b3Fmod

@Cast(value="b3Scalar")
public static float b3Fmod(@Cast(value="b3Scalar")
                                                   float x,
                                                   @Cast(value="b3Scalar")
                                                   float y)

B3_2_PI

@MemberGetter
public static double B3_2_PI()

B3_PI

@MemberGetter
public static double B3_PI()

B3_HALF_PI

@MemberGetter
public static double B3_HALF_PI()

B3_RADS_PER_DEG

@MemberGetter
public static double B3_RADS_PER_DEG()

B3_DEGS_PER_RAD

@MemberGetter
public static double B3_DEGS_PER_RAD()

B3_SQRT12

@MemberGetter
public static double B3_SQRT12()

B3_EPSILON

@MemberGetter
public static float B3_EPSILON()

B3_INFINITY

@MemberGetter
public static float B3_INFINITY()

b3Atan2Fast

@Cast(value="b3Scalar")
public static float b3Atan2Fast(@Cast(value="b3Scalar")
                                                        float y,
                                                        @Cast(value="b3Scalar")
                                                        float x)

b3FuzzyZero

@Cast(value="bool")
public static boolean b3FuzzyZero(@Cast(value="b3Scalar")
                                                      float x)

b3Equal

@Cast(value="bool")
public static boolean b3Equal(@Cast(value="b3Scalar")
                                                  float a,
                                                  @Cast(value="b3Scalar")
                                                  float eps)

b3GreaterEqual

@Cast(value="bool")
public static boolean b3GreaterEqual(@Cast(value="b3Scalar")
                                                         float a,
                                                         @Cast(value="b3Scalar")
                                                         float eps)

b3IsNegative

public static int b3IsNegative(@Cast(value="b3Scalar")
                               float x)

b3Radians

@Cast(value="b3Scalar")
public static float b3Radians(@Cast(value="b3Scalar")
                                                      float x)

b3Degrees

@Cast(value="b3Scalar")
public static float b3Degrees(@Cast(value="b3Scalar")
                                                      float x)

b3Fsel

@Cast(value="b3Scalar")
public static float b3Fsel(@Cast(value="b3Scalar")
                                                   float a,
                                                   @Cast(value="b3Scalar")
                                                   float b,
                                                   @Cast(value="b3Scalar")
                                                   float c)

b3MachineIsLittleEndian

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

b3Select

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

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

b3Select

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

b3SwapEndian

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

b3SwapEndian

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

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

b3UnswapEndianFloat

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

b3SwapEndianDouble

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

b3SwapEndianDouble

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

b3SwapEndianDouble

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

b3UnswapEndianDouble

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

b3UnswapEndianDouble

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

b3UnswapEndianDouble

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

b3NormalizeAngle

@Cast(value="b3Scalar")
public static float b3NormalizeAngle(@Cast(value="b3Scalar")
                                                             float angleInRadians)

b3MakeVector3

@ByVal
public static b3Vector3 b3MakeVector3(@Cast(value="b3Scalar")
                                             float x,
                                             @Cast(value="b3Scalar")
                                             float y,
                                             @Cast(value="b3Scalar")
                                             float z)

b3MakeVector3

@ByVal
public static b3Vector3 b3MakeVector3(@Cast(value="b3Scalar")
                                             float x,
                                             @Cast(value="b3Scalar")
                                             float y,
                                             @Cast(value="b3Scalar")
                                             float z,
                                             @Cast(value="b3Scalar")
                                             float w)

b3MakeVector4

@ByVal
public static b3Vector4 b3MakeVector4(@Cast(value="b3Scalar")
                                             float x,
                                             @Cast(value="b3Scalar")
                                             float y,
                                             @Cast(value="b3Scalar")
                                             float z,
                                             @Cast(value="b3Scalar")
                                             float w)

add

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

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

multiply

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

\brief Return the elementwise product of two vectors

subtract

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

\brief Return the difference between two vectors

subtract

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

\brief Return the negative of the vector

multiply

@ByVal
 @Name(value="operator *")
public static b3Vector3 multiply(@Const @ByRef
                                                                   b3Vector3 v,
                                                                   @Cast(value="const b3Scalar")
                                                                   float s)

\brief Return the vector scaled by s

multiply

@ByVal
 @Name(value="operator *")
public static b3Vector3 multiply(@Cast(value="const b3Scalar")
                                                                   float s,
                                                                   @Const @ByRef
                                                                   b3Vector3 v)

\brief Return the vector scaled by s

divide

@ByVal
 @Name(value="operator /")
public static b3Vector3 divide(@Const @ByRef
                                                                 b3Vector3 v,
                                                                 @Cast(value="const b3Scalar")
                                                                 float s)

\brief Return the vector inversely scaled by s

divide

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

\brief Return the vector inversely scaled by s

b3Dot

@Cast(value="b3Scalar")
public static float b3Dot(@Const @ByRef
                                                  b3Vector3 v1,
                                                  @Const @ByRef
                                                  b3Vector3 v2)

\brief Return the dot product between two vectors

b3Distance2

@Cast(value="b3Scalar")
public static float b3Distance2(@Const @ByRef
                                                        b3Vector3 v1,
                                                        @Const @ByRef
                                                        b3Vector3 v2)

\brief Return the distance squared between two vectors

b3Distance

@Cast(value="b3Scalar")
public static float b3Distance(@Const @ByRef
                                                       b3Vector3 v1,
                                                       @Const @ByRef
                                                       b3Vector3 v2)

\brief Return the distance between two vectors

b3Angle

@Cast(value="b3Scalar")
public static float b3Angle(@Const @ByRef
                                                    b3Vector3 v1,
                                                    @Const @ByRef
                                                    b3Vector3 v2)

\brief Return the angle between two vectors

b3Cross

@ByVal
public static b3Vector3 b3Cross(@Const @ByRef
                                       b3Vector3 v1,
                                       @Const @ByRef
                                       b3Vector3 v2)

\brief Return the cross product of two vectors

b3Triple

@Cast(value="b3Scalar")
public static float b3Triple(@Const @ByRef
                                                     b3Vector3 v1,
                                                     @Const @ByRef
                                                     b3Vector3 v2,
                                                     @Const @ByRef
                                                     b3Vector3 v3)

b3Lerp

@ByVal
public static b3Vector3 b3Lerp(@Const @ByRef
                                      b3Vector3 v1,
                                      @Const @ByRef
                                      b3Vector3 v2,
                                      @Cast(value="const b3Scalar")
                                      float 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)

b3SwapScalarEndian

public static void b3SwapScalarEndian(@Cast(value="const b3Scalar")
                                      float sourceVal,
                                      @Cast(value="b3Scalar*") @ByRef
                                      FloatPointer destVal)

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

b3SwapScalarEndian

public static void b3SwapScalarEndian(@Cast(value="const b3Scalar")
                                      float sourceVal,
                                      @Cast(value="b3Scalar*") @ByRef
                                      FloatBuffer destVal)

b3SwapScalarEndian

public static void b3SwapScalarEndian(@Cast(value="const b3Scalar")
                                      float sourceVal,
                                      @Cast(value="b3Scalar*") @ByRef
                                      float[] destVal)

b3SwapVector3Endian

public static void b3SwapVector3Endian(@Const @ByRef
                                       b3Vector3 sourceVec,
                                       @ByRef
                                       b3Vector3 destVec)

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

b3UnSwapVector3Endian

public static void b3UnSwapVector3Endian(@ByRef
                                         b3Vector3 vector)

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

multiply

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

\brief Return the product of two quaternions

multiply

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

multiply

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

b3Dot

@Cast(value="b3Scalar")
public static float b3Dot(@Const @ByRef
                                                  b3Quaternion q1,
                                                  @Const @ByRef
                                                  b3Quaternion q2)

\brief Calculate the dot product between two quaternions

b3Length

@Cast(value="b3Scalar")
public static float b3Length(@Const @ByRef
                                                     b3Quaternion q)

\brief Return the length of a quaternion

b3Angle

@Cast(value="b3Scalar")
public static float b3Angle(@Const @ByRef
                                                    b3Quaternion q1,
                                                    @Const @ByRef
                                                    b3Quaternion q2)

\brief Return the angle between two quaternions

b3Inverse

@ByVal
public static b3Quaternion b3Inverse(@Const @ByRef
                                            b3Quaternion q)

\brief Return the inverse of a quaternion

b3Slerp

@ByVal
public static b3Quaternion b3Slerp(@Const @ByRef
                                          b3Quaternion q1,
                                          @Const @ByRef
                                          b3Quaternion q2,
                                          @Cast(value="const b3Scalar")
                                          float 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.

b3QuatMul

@ByVal
public static b3Quaternion b3QuatMul(@Const @ByRef
                                            b3Quaternion rot0,
                                            @Const @ByRef
                                            b3Quaternion rot1)

b3QuatNormalized

@ByVal
public static b3Quaternion b3QuatNormalized(@Const @ByRef
                                                   b3Quaternion orn)

b3QuatRotate

@ByVal
public static b3Vector3 b3QuatRotate(@Const @ByRef
                                            b3Quaternion rotation,
                                            @Const @ByRef
                                            b3Vector3 v)

b3ShortestArcQuat

@ByVal
public static b3Quaternion b3ShortestArcQuat(@Const @ByRef
                                                    b3Vector3 v0,
                                                    @Const @ByRef
                                                    b3Vector3 v1)

b3ShortestArcQuatNormalize2

@ByVal
public static b3Quaternion b3ShortestArcQuatNormalize2(@ByRef
                                                              b3Vector3 v0,
                                                              @ByRef
                                                              b3Vector3 v1)

multiply

@ByVal
 @Name(value="operator *")
public static b3Matrix3x3 multiply(@Const @ByRef
                                                                     b3Matrix3x3 m,
                                                                     @Cast(value="const b3Scalar")
                                                                     float k)

add

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

subtract

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

multiply

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

multiply

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

multiply

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

equals

@Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                             b3Matrix3x3 m1,
                                                                             @Const @ByRef
                                                                             b3Matrix3x3 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
                                                                             b3Transform t1,
                                                                             @Const @ByRef
                                                                             b3Transform t2)

\brief Test if two transforms have all elements equal

B3_ANGULAR_MOTION_THRESHOLD

@MemberGetter
public static double B3_ANGULAR_MOTION_THRESHOLD()

b3AabbSupport

@ByVal
public static b3Vector3 b3AabbSupport(@Const @ByRef
                                             b3Vector3 halfExtents,
                                             @Const @ByRef
                                             b3Vector3 supportDir)

b3Normalized

@ByVal
public static b3Vector3 b3Normalized(@Const @ByRef
                                            b3Vector3 vec)

b3FastNormalized3

@ByVal
public static b3Vector3 b3FastNormalized3(@Const @ByRef
                                                 b3Vector3 v)

b3MaxFloat4

@ByVal
public static b3Vector3 b3MaxFloat4(@Const @ByRef
                                           b3Vector3 a,
                                           @Const @ByRef
                                           b3Vector3 b)

b3MinFloat4

@ByVal
public static b3Vector3 b3MinFloat4(@Const @ByRef
                                           b3Vector3 a,
                                           @Const @ByRef
                                           b3Vector3 b)

b3IsAlmostZero

@Cast(value="bool")
public static boolean b3IsAlmostZero(@Const @ByRef
                                                         b3Vector3 v)

b3MaxDot

public static int b3MaxDot(@Const @ByRef
                           b3Vector3 vec,
                           @Const
                           b3Vector3 vecArray,
                           int vecLen,
                           FloatPointer dotOut)

b3MaxDot

public static int b3MaxDot(@Const @ByRef
                           b3Vector3 vec,
                           @Const
                           b3Vector3 vecArray,
                           int vecLen,
                           FloatBuffer dotOut)

b3MaxDot

public static int b3MaxDot(@Const @ByRef
                           b3Vector3 vec,
                           @Const
                           b3Vector3 vecArray,
                           int vecLen,
                           float[] dotOut)

b3MakeInt2

@ByVal
public static b3Int2 b3MakeInt2(int x,
                                       int y)

b3MakeInt4

@ByVal
public static b3Int4 b3MakeInt4(int x,
                                       int y,
                                       int z,
                                       int w)

b3MakeInt4

@ByVal
public static b3Int4 b3MakeInt4(int x,
                                       int y,
                                       int z)

b3MakeUnsignedInt4

@ByVal
public static b3UnsignedInt4 b3MakeUnsignedInt4(@Cast(value="unsigned int")
                                                       int x,
                                                       @Cast(value="unsigned int")
                                                       int y,
                                                       @Cast(value="unsigned int")
                                                       int z,
                                                       @Cast(value="unsigned int")
                                                       int w)

b3MakeUnsignedInt4

@ByVal
public static b3UnsignedInt4 b3MakeUnsignedInt4(@Cast(value="unsigned int")
                                                       int x,
                                                       @Cast(value="unsigned int")
                                                       int y,
                                                       @Cast(value="unsigned int")
                                                       int z)

b3QuatInverse

@ByVal
public static b3Quaternion b3QuatInverse(@Const @ByRef
                                                b3Quaternion orn)

b3TransformPoint

@ByVal
public static b3Vector3 b3TransformPoint(@Const @ByRef
                                                b3Vector3 point,
                                                @Const @ByRef
                                                b3Vector3 translation,
                                                @Const @ByRef
                                                b3Quaternion orientation)

b3QuatGetRotationMatrix

@ByVal
public static b3Matrix3x3 b3QuatGetRotationMatrix(@Const @ByRef
                                                         b3Quaternion quat)

b3AbsoluteMat3x3

@ByVal
public static b3Matrix3x3 b3AbsoluteMat3x3(@Const @ByRef
                                                  b3Matrix3x3 mat)

mtMul3

@ByVal
public static b3Vector3 mtMul3(@Const @ByRef
                                      b3Vector3 a,
                                      @Const @ByRef
                                      b3Matrix3x3 b)

b3AtomicAdd

public static int b3AtomicAdd(IntPointer p,
                              int val)

b3AtomicAdd

public static int b3AtomicAdd(IntBuffer p,
                              int val)

b3AtomicAdd

public static int b3AtomicAdd(int[] p,
                              int val)

Class Bullet3Common

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

B3_USE_PLACEMENT_NEW

B3_BULLET_VERSION

B3_LARGE_FLOAT

B3_2_PI

B3_PI

B3_HALF_PI

B3_RADS_PER_DEG

B3_DEGS_PER_RAD

B3_SQRT12

B3_EPSILON

B3_INFINITY

b3Vector3DataName

B3_POOL_HANDLE_TERMINAL_FREE

B3_POOL_HANDLE_TERMINAL_USED

B3_ANGULAR_MOTION_THRESHOLD

Constructor Detail

Bullet3Common

Method Detail

B3_HASH_NULL

b3EnterProfileZone

b3EnterProfileZone

b3LeaveProfileZone

b3SetCustomPrintfFunc

b3SetCustomWarningMessageFunc

b3SetCustomErrorMessageFunc

b3SetCustomEnterProfileZoneFunc

b3SetCustomLeaveProfileZoneFunc

b3OutputPrintfVarArgsInternal

b3OutputPrintfVarArgsInternal

b3OutputWarningMessageVarArgsInternal

b3OutputWarningMessageVarArgsInternal

b3OutputErrorMessageVarArgsInternal

b3OutputErrorMessageVarArgsInternal

b3GetVersion

B3_LARGE_FLOAT

b3Sqrt

b3Fabs

b3Cos

b3Sin

b3Tan

b3Acos

b3Asin

b3Atan

b3Atan2

b3Exp

b3Log

b3Pow

b3Fmod

B3_2_PI

B3_PI

B3_HALF_PI

B3_RADS_PER_DEG

B3_DEGS_PER_RAD

B3_SQRT12

B3_EPSILON

B3_INFINITY

b3Atan2Fast

b3FuzzyZero

b3Equal

b3GreaterEqual

b3IsNegative

b3Radians

b3Degrees

b3Fsel

b3MachineIsLittleEndian

b3Select

b3Select

b3SwapEndian

b3SwapEndian

b3SwapEndianFloat

b3UnswapEndianFloat

b3SwapEndianDouble

b3SwapEndianDouble