org.bytedeco.bullet.Bullet3Common

Class b3Quaternion

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.bullet.Bullet3Common.b3QuadWord

org.bytedeco.bullet.Bullet3Common.b3Quaternion

All Implemented Interfaces:

AutoCloseable

@Properties(inherit=Bullet3Common.class)
public class b3Quaternion
extends b3QuadWord

\brief The b3Quaternion implements quaternion to perform linear algebra rotations in combination with b3Matrix3x3, b3Vector3 and b3Transform.

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
b3Quaternion() \brief No initialization constructor
b3Quaternion(b3Vector3 _axis, float _angle) \brief Axis angle Constructor
b3Quaternion(float yaw, float pitch, float roll) \brief Constructor from Euler angles
b3Quaternion(float _x, float _y, float _z, float _w) \brief Constructor from scalars
b3Quaternion(long size) Native array allocator.
b3Quaternion(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
b3Quaternion	add(b3Quaternion q2) \brief Return the sum of this quaternion and the other
b3Quaternion	addPut(b3Quaternion q) \brief Add two quaternions
float	angle(b3Quaternion q) \brief Return the angle between this quaternion and the other
b3Quaternion	divide(float s) \brief Return an inversely scaled versionof this quaternion
b3Quaternion	dividePut(float s) \brief Inversely scale this quaternion
float	dot(b3Quaternion q) \brief Return the dot product between this quaternion and another
b3Quaternion	farthest(b3Quaternion qd) \todo document this and it's use
float	getAngle() \brief Return the angle of rotation represented by this quaternion
b3Vector3	getAxis() \brief Return the axis of the rotation represented by this quaternion
void	getEulerZYX(float[] yawZ, float[] pitchY, float[] rollX)
void	getEulerZYX(FloatBuffer yawZ, FloatBuffer pitchY, FloatBuffer rollX)
void	getEulerZYX(FloatPointer yawZ, FloatPointer pitchY, FloatPointer rollX) \brief Get the euler angles from this quaternion
static b3Quaternion	getIdentity()
b3Quaternion	getPointer(long i)
float	getW()
b3Quaternion	inverse() \brief Return the inverse of this quaternion
float	length() \brief Return the length of the quaternion
float	length2() \brief Return the length squared of the quaternion
b3Quaternion	multiply(float s) \brief Return a scaled version of this quaternion
b3Quaternion	multiplyPut(b3Quaternion q) \brief Multiply this quaternion by q on the right
b3Quaternion	multiplyPut(float s) \brief Scale this quaternion
b3Quaternion	nearest(b3Quaternion qd) \todo document this and it's use
b3Quaternion	normalize() \brief Normalize the quaternion Such that x^2 + y^2 + z^2 +w^2 = 1
b3Quaternion	normalized() \brief Return a normalized version of this quaternion
b3Quaternion	position(long position)
void	setEuler(float yaw, float pitch, float roll) \brief Set the quaternion using Euler angles
void	setEulerZYX(float yawZ, float pitchY, float rollX) \brief Set the quaternion using euler angles
void	setRotation(b3Vector3 axis1, float _angle) \brief Set the rotation using axis angle notation
b3Quaternion	slerp(b3Quaternion q, float t) \brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion
b3Quaternion	subtract() \brief Return the negative of this quaternion This simply negates each element
b3Quaternion	subtract(b3Quaternion q2) \brief Return the difference between this quaternion and the other
b3Quaternion	subtractPut(b3Quaternion q) \brief Subtract out a quaternion

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

asFloatPointer, equals, getX, getY, getZ, m_floats, m_floats, m_floats, notEquals, setMax, setMin, setValue, setValue, setW, setX, setY, setZ, w, w, x, x, y, y, z, z

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, getDirectBufferAddress, getPointer, getPointer, getPointer, hashCode, interruptDeallocatorThread, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetAddress, offsetof, offsetof, parseBytes, physicalBytes, physicalBytesInaccurate, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, sizeof, toString, totalBytes, totalCount, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

b3Quaternion

public b3Quaternion(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

b3Quaternion

public b3Quaternion(long size)

Native array allocator. Access with Pointer.position(long).

b3Quaternion

public b3Quaternion()

\brief No initialization constructor

b3Quaternion

public b3Quaternion(@Cast(value="const b3Scalar")
                    float _x,
                    @Cast(value="const b3Scalar")
                    float _y,
                    @Cast(value="const b3Scalar")
                    float _z,
                    @Cast(value="const b3Scalar")
                    float _w)

\brief Constructor from scalars

b3Quaternion

public b3Quaternion(@Const @ByRef
                    b3Vector3 _axis,
                    @Cast(value="const b3Scalar")
                    float _angle)

\brief Axis angle Constructor

Parameters:

axis - The axis which the rotation is around

angle - The magnitude of the rotation around the angle (Radians)

b3Quaternion

public b3Quaternion(@Cast(value="const b3Scalar")
                    float yaw,
                    @Cast(value="const b3Scalar")
                    float pitch,
                    @Cast(value="const b3Scalar")
                    float roll)

\brief Constructor from Euler angles

Parameters:

yaw - Angle around Y unless B3_EULER_DEFAULT_ZYX defined then Z

pitch - Angle around X unless B3_EULER_DEFAULT_ZYX defined then Y

roll - Angle around Z unless B3_EULER_DEFAULT_ZYX defined then X

Method Detail

position

public b3Quaternion position(long position)

Overrides:

position in class b3QuadWord

getPointer

public b3Quaternion getPointer(long i)

Overrides:

getPointer in class b3QuadWord

setRotation

public void setRotation(@Const @ByRef
                        b3Vector3 axis1,
                        @Cast(value="const b3Scalar")
                        float _angle)

\brief Set the rotation using axis angle notation

Parameters:

axis - The axis around which to rotate

angle - The magnitude of the rotation in Radians

setEuler

public void setEuler(@Cast(value="const b3Scalar")
                     float yaw,
                     @Cast(value="const b3Scalar")
                     float pitch,
                     @Cast(value="const b3Scalar")
                     float roll)

\brief Set the quaternion using Euler angles

Parameters:

yaw - Angle around Y

pitch - Angle around X

roll - Angle around Z

setEulerZYX

public void setEulerZYX(@Cast(value="const b3Scalar")
                        float yawZ,
                        @Cast(value="const b3Scalar")
                        float pitchY,
                        @Cast(value="const b3Scalar")
                        float rollX)

\brief Set the quaternion using euler angles

Parameters:

yaw - Angle around Z

pitch - Angle around Y

roll - Angle around X

getEulerZYX

public void getEulerZYX(@Cast(value="b3Scalar*") @ByRef
                        FloatPointer yawZ,
                        @Cast(value="b3Scalar*") @ByRef
                        FloatPointer pitchY,
                        @Cast(value="b3Scalar*") @ByRef
                        FloatPointer rollX)

\brief Get the euler angles from this quaternion

Parameters:

yaw - Angle around Z

pitch - Angle around Y

roll - Angle around X

getEulerZYX

public void getEulerZYX(@Cast(value="b3Scalar*") @ByRef
                        FloatBuffer yawZ,
                        @Cast(value="b3Scalar*") @ByRef
                        FloatBuffer pitchY,
                        @Cast(value="b3Scalar*") @ByRef
                        FloatBuffer rollX)

getEulerZYX

public void getEulerZYX(@Cast(value="b3Scalar*") @ByRef
                        float[] yawZ,
                        @Cast(value="b3Scalar*") @ByRef
                        float[] pitchY,
                        @Cast(value="b3Scalar*") @ByRef
                        float[] rollX)

addPut

@ByRef
 @Name(value="operator +=")
public b3Quaternion addPut(@Const @ByRef
                                                              b3Quaternion q)

\brief Add two quaternions

Parameters:

q - The quaternion to add to this one

subtractPut

@ByRef
 @Name(value="operator -=")
public b3Quaternion subtractPut(@Const @ByRef
                                                                   b3Quaternion q)

\brief Subtract out a quaternion

Parameters:

q - The quaternion to subtract from this one

multiplyPut

@ByRef
 @Name(value="operator *=")
public b3Quaternion multiplyPut(@Cast(value="const b3Scalar")
                                                                   float s)

\brief Scale this quaternion

Parameters:

s - The scalar to scale by

multiplyPut

@ByRef
 @Name(value="operator *=")
public b3Quaternion multiplyPut(@Const @ByRef
                                                                   b3Quaternion q)

\brief Multiply this quaternion by q on the right

Parameters:

q - The other quaternion Equivilant to this = this * q

dot

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

\brief Return the dot product between this quaternion and another

Parameters:

q - The other quaternion

length2

@Cast(value="b3Scalar")
public float length2()

\brief Return the length squared of the quaternion

length

@Cast(value="b3Scalar")
public float length()

\brief Return the length of the quaternion

normalize

@ByRef
public b3Quaternion normalize()

\brief Normalize the quaternion Such that x^2 + y^2 + z^2 +w^2 = 1

multiply

@ByVal
 @Name(value="operator *")
public b3Quaternion multiply(@Cast(value="const b3Scalar")
                                                               float s)

\brief Return a scaled version of this quaternion

Parameters:

s - The scale factor

divide

@ByVal
 @Name(value="operator /")
public b3Quaternion divide(@Cast(value="const b3Scalar")
                                                             float s)

\brief Return an inversely scaled versionof this quaternion

Parameters:

s - The inverse scale factor

dividePut

@ByRef
 @Name(value="operator /=")
public b3Quaternion dividePut(@Cast(value="const b3Scalar")
                                                                 float s)

\brief Inversely scale this quaternion

Parameters:

s - The scale factor

normalized

@ByVal
public b3Quaternion normalized()

\brief Return a normalized version of this quaternion

angle

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

\brief Return the angle between this quaternion and the other

Parameters:

q - The other quaternion

getAngle

@Cast(value="b3Scalar")
public float getAngle()

\brief Return the angle of rotation represented by this quaternion

getAxis

@ByVal
public b3Vector3 getAxis()

\brief Return the axis of the rotation represented by this quaternion

inverse

@ByVal
public b3Quaternion inverse()

\brief Return the inverse of this quaternion

add

@ByVal
 @Name(value="operator +")
public b3Quaternion add(@Const @ByRef
                                                          b3Quaternion q2)

\brief Return the sum of this quaternion and the other

Parameters:

q2 - The other quaternion

subtract

@ByVal
 @Name(value="operator -")
public b3Quaternion subtract(@Const @ByRef
                                                               b3Quaternion q2)

\brief Return the difference between this quaternion and the other

Parameters:

q2 - The other quaternion

subtract

@ByVal
 @Name(value="operator -")
public b3Quaternion subtract()

\brief Return the negative of this quaternion This simply negates each element

farthest

@ByVal
public b3Quaternion farthest(@Const @ByRef
                                    b3Quaternion qd)

\todo document this and it's use

nearest

@ByVal
public b3Quaternion nearest(@Const @ByRef
                                   b3Quaternion qd)

\todo document this and it's use

slerp

@ByVal
public b3Quaternion slerp(@Const @ByRef
                                 b3Quaternion q,
                                 @Cast(value="const b3Scalar")
                                 float t)

\brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion

Parameters:

q - The other quaternion to interpolate with

t - The ratio between this and q to interpolate. If t = 0 the result is this, if t=1 the result is q. Slerp interpolates assuming constant velocity.

getIdentity

@Const
 @ByRef
public static b3Quaternion getIdentity()

getW

@Cast(value="const b3Scalar")
public float getW()