liquidfun (JavaCPP Presets for LiquidFun master-1.5.8 API)

java.lang.Object
- org.bytedeco.liquidfun.presets.liquidfun
- - org.bytedeco.liquidfun.global.liquidfun

All Implemented Interfaces:: InfoMapper

public class liquidfun
extends liquidfun

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`b2_aabbExtension` This is used to fatten AABBs in the dynamic tree.
`static double`	`b2_aabbMultiplier` This is used to fatten AABBs in the dynamic tree.
`static int`	`b2_addState` enum b2PointState
`static double`	`b2_angularSleepTolerance` A body cannot sleep if its angular velocity is above this tolerance.
`static double`	`b2_angularSlop` A small angle used as a collision and constraint tolerance.
`static int`	`B2_ASSERT_ENABLED`
`static double`	`b2_barrierCollisionTime` The time into the future that collisions against barrier particles will be detected.
`static int`	`b2_barrierParticle` enum b2ParticleFlag
`static double`	`b2_baumgarte` This scale factor controls how fast overlap is resolved.
`static int`	`b2_colorMixingParticle` enum b2ParticleFlag
`static int`	`b2_destructionListenerParticle` enum b2ParticleFlag
`static int`	`b2_dynamicBody` enum b2BodyType
`static int`	`b2_elasticParticle` enum b2ParticleFlag
`static int`	`b2_fixtureContactFilterParticle` enum b2ParticleFlag
`static int`	`b2_fixtureContactListenerParticle` enum b2ParticleFlag
`static int`	`B2_INTRUSIVE_LIST_VALIDATE` Normalize an angle in radians to be between -pi and pi
`static int`	`b2_invalidParticleIndex` A symbolic constant that stands for particle allocation error.
`static int`	`b2_kinematicBody` enum b2BodyType
`static double`	`b2_linearSleepTolerance` A body cannot sleep if its linear velocity is above this tolerance.
`static double`	`b2_linearSlop` A small length used as a collision and constraint tolerance.
`static double`	`b2_maxAngularCorrection` The maximum angular position correction used when solving constraints.
`static double`	`b2_maxLinearCorrection` The maximum linear position correction used when solving constraints.
`static int`	`b2_maxManifoldPoints` The maximum number of contact points between two convex shapes.
`static double`	`b2_maxParticleForce` The upper limit for force between particles.
`static int`	`b2_maxParticleIndex`
`static double`	`b2_maxParticlePressure` The upper limit for particle pressure.
`static int`	`b2_maxPolygonVertices` The maximum number of vertices on a convex polygon.
`static double`	`b2_maxRotation` The maximum angular velocity of a body.
`static int`	`b2_maxSubSteps` Maximum number of sub-steps per contact in continuous physics simulation.
`static int`	`b2_maxTOIContacts` Maximum number of contacts to be handled to solve a TOI impact.
`static double`	`b2_maxTranslation` The maximum linear velocity of a body.
`static int`	`b2_maxTriadDistance` The maximum distance between particles in a triad, multiplied by the particle diameter.
`static int`	`b2_maxTriadDistanceSquared`
`static int`	`b2_minParticleSystemBufferCapacity` The initial size of particle data buffers.
`static double`	`b2_minParticleWeight` The minimum particle weight that produces pressure.
`static int`	`b2_nullNode`
`static int`	`b2_nullState` enum b2PointState
`static int`	`b2_particleContactFilterParticle` enum b2ParticleFlag
`static int`	`b2_particleContactListenerParticle` enum b2ParticleFlag
`static int`	`b2_particleGroupCanBeEmpty` enum b2ParticleGroupFlag
`static int`	`b2_particleGroupInternalMask` enum b2ParticleGroupFlag
`static int`	`b2_particleGroupNeedsUpdateDepth` enum b2ParticleGroupFlag
`static int`	`b2_particleGroupWillBeDestroyed` enum b2ParticleGroupFlag
`static double`	`b2_particleStride` The default distance between particles, multiplied by the particle diameter.
`static int`	`b2_persistState` enum b2PointState
`static double`	`b2_pi`
`static double`	`b2_polygonRadius` The radius of the polygon/edge shape skin.
`static int`	`b2_powderParticle` enum b2ParticleFlag
`static int`	`b2_reactiveParticle` enum b2ParticleFlag
`static int`	`b2_removeState` enum b2PointState
`static int`	`b2_repulsiveParticle` enum b2ParticleFlag
`static int`	`b2_rigidParticleGroup` enum b2ParticleGroupFlag
`static int`	`b2_solidParticleGroup` enum b2ParticleGroupFlag
`static int`	`b2_springParticle` enum b2ParticleFlag
`static int`	`b2_staticBody` enum b2BodyType
`static int`	`b2_staticPressureParticle` enum b2ParticleFlag
`static int`	`b2_tensileParticle` enum b2ParticleFlag
`static double`	`b2_timeToSleep` The time that a body must be still before it will go to sleep.
`static double`	`b2_toiBaugarte`
`static double`	`b2_velocityThreshold` A velocity threshold for elastic collisions.
`static int`	`b2_viscousParticle` enum b2ParticleFlag
`static int`	`b2_wallParticle` enum b2ParticleFlag
`static int`	`b2_waterParticle` enum b2ParticleFlag
`static int`	`b2_zombieParticle` enum b2ParticleFlag
`static int`	`e_atLowerLimit` enum b2LimitState
`static int`	`e_atUpperLimit` enum b2LimitState
`static int`	`e_distanceJoint` enum b2JointType
`static int`	`e_equalLimits` enum b2LimitState
`static int`	`e_frictionJoint` enum b2JointType
`static int`	`e_gearJoint` enum b2JointType
`static int`	`e_inactiveLimit` enum b2LimitState
`static int`	`e_motorJoint` enum b2JointType
`static int`	`e_mouseJoint` enum b2JointType
`static int`	`e_prismaticJoint` enum b2JointType
`static int`	`e_pulleyJoint` enum b2JointType
`static int`	`e_revoluteJoint` enum b2JointType
`static int`	`e_ropeJoint` enum b2JointType
`static int`	`e_unknownJoint` enum b2JointType
`static int`	`e_weldJoint` enum b2JointType
`static int`	`e_wheelJoint` enum b2JointType
`static int`	`LIQUIDFUN_EXTERNAL_LANGUAGE_API`

Constructor Summary

Constructors
Constructor and Description

liquidfun()

Constructors
Constructor and Description
`liquidfun()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static b2Mat22`	`add(b2Mat22 A, b2Mat22 B)`
`static b2Vec2`	`add(b2Vec2 a, b2Vec2 b)` Add two vectors component-wise.
`static b2Vec2`	`add(b2Vec2 v, float f)` Add a float to a vector.
`static b2Vec3`	`add(b2Vec3 a, b2Vec3 b)` Add two vectors component-wise.
`static b2Version`	`b2_liquidFunVersion()` Global variable is used to identify the version of LiquidFun.
`static BytePointer`	`b2_liquidFunVersionString()` String which identifies the current version of LiquidFun.
`static void`	`b2_liquidFunVersionString(BytePointer setter)`
`static float`	`b2_minPulleyLength()`
`static short`	`b2_nullFeature()` \file Structures and functions used for computing contact points, distance queries, and TOI queries.
`static b2Version`	`b2_version()` Current version.
`static void`	`b2_version(b2Version setter)`
`static b2Mat22`	`b2Abs(b2Mat22 A)`
`static b2Vec2`	`b2Abs(b2Vec2 a)`
`static Pointer`	`b2Alloc(int size)` Implement this function to use your own memory allocator.
`static int`	`b2CalculateParticleIterations(float gravity, float radius, float timeStep)` A helper function to calculate the optimal number of iterations.
`static b2Vec2`	`b2Clamp(b2Vec2 a, b2Vec2 low, b2Vec2 high)`
`static int`	`b2ClipSegmentToLine(b2ClipVertex vOut, b2ClipVertex vIn, b2Vec2 normal, float offset, int vertexIndexA)` Clipping for contact manifolds.
`static void`	`b2CollideCircles(b2Manifold manifold, b2CircleShape circleA, b2Transform xfA, b2CircleShape circleB, b2Transform xfB)` Compute the collision manifold between two circles.
`static void`	`b2CollideEdgeAndCircle(b2Manifold manifold, b2EdgeShape polygonA, b2Transform xfA, b2CircleShape circleB, b2Transform xfB)` Compute the collision manifold between an edge and a circle.
`static void`	`b2CollideEdgeAndPolygon(b2Manifold manifold, b2EdgeShape edgeA, b2Transform xfA, b2PolygonShape circleB, b2Transform xfB)` Compute the collision manifold between an edge and a circle.
`static void`	`b2CollidePolygonAndCircle(b2Manifold manifold, b2PolygonShape polygonA, b2Transform xfA, b2CircleShape circleB, b2Transform xfB)` Compute the collision manifold between a polygon and a circle.
`static void`	`b2CollidePolygons(b2Manifold manifold, b2PolygonShape polygonA, b2Transform xfA, b2PolygonShape polygonB, b2Transform xfB)` Compute the collision manifold between two polygons.
`static float`	`b2Cross(b2Vec2 a, b2Vec2 b)` Perform the cross product on two vectors.
`static b2Vec2`	`b2Cross(b2Vec2 a, float s)` Perform the cross product on a vector and a scalar.
`static b2Vec3`	`b2Cross(b2Vec3 a, b2Vec3 b)` Perform the cross product on two vectors.
`static b2Vec2`	`b2Cross(float s, b2Vec2 a)` Perform the cross product on a scalar and a vector.
`static void`	`b2Distance(b2DistanceOutput output, b2SimplexCache cache, b2DistanceInput input)` Compute the closest points between two shapes.
`static float`	`b2Distance(b2Vec2 a, b2Vec2 b)`
`static float`	`b2DistanceSquared(b2Vec2 a, b2Vec2 b)`
`static float`	`b2Dot(b2Vec2 a, b2Vec2 b)` Perform the dot product on two vectors.
`static float`	`b2Dot(b2Vec3 a, b2Vec3 b)` Perform the dot product on two vectors.
`static void`	`b2Free(Pointer mem)` If you implement b2Alloc, you should also implement this function.
`static int`	`b2GetNumAllocs()` Get number of calls to b2Alloc minus number of calls to b2Free.
`static void`	`b2GetPointStates(int[] state1, int[] state2, b2Manifold manifold1, b2Manifold manifold2)`
`static void`	`b2GetPointStates(IntBuffer state1, IntBuffer state2, b2Manifold manifold1, b2Manifold manifold2)`
`static void`	`b2GetPointStates(IntPointer state1, IntPointer state2, b2Manifold manifold1, b2Manifold manifold2)` Compute the point states given two manifolds.
`static float`	`b2InvSqrt(float x)` This is a approximate yet fast inverse square-root.
`static boolean`	`b2IsPowerOfTwo(long x)`
`static boolean`	`b2IsValid(float x)` This function is used to ensure that a floating point number is not a NaN or infinity.
`static void`	`b2Log(BytePointer string)` Logging function.
`static void`	`b2Log(String string)`
`static b2Vec2`	`b2Max(b2Vec2 a, b2Vec2 b)`
`static b2Vec2`	`b2Min(b2Vec2 a, b2Vec2 b)`
`static float`	`b2MixFriction(float friction1, float friction2)` Friction mixing law.
`static float`	`b2MixRestitution(float restitution1, float restitution2)` Restitution mixing law.
`static b2Mat22`	`b2Mul(b2Mat22 A, b2Mat22 B)`
`static b2Vec2`	`b2Mul(b2Mat22 A, b2Vec2 v)` Multiply a matrix times a vector.
`static b2Vec3`	`b2Mul(b2Mat33 A, b2Vec3 v)` Multiply a matrix times a vector.
`static b2Rot`	`b2Mul(b2Rot q, b2Rot r)` Multiply two rotations: q * r
`static b2Vec2`	`b2Mul(b2Rot q, b2Vec2 v)` Rotate a vector
`static b2Transform`	`b2Mul(b2Transform A, b2Transform B)`
`static b2Vec2`	`b2Mul(b2Transform T, b2Vec2 v)`
`static b2Vec2`	`b2Mul22(b2Mat33 A, b2Vec2 v)` Multiply a matrix times a vector.
`static b2Mat22`	`b2MulT(b2Mat22 A, b2Mat22 B)`
`static b2Vec2`	`b2MulT(b2Mat22 A, b2Vec2 v)` Multiply a matrix transpose times a vector.
`static b2Rot`	`b2MulT(b2Rot q, b2Rot r)` Transpose multiply two rotations: qT * r
`static b2Vec2`	`b2MulT(b2Rot q, b2Vec2 v)` Inverse rotate a vector
`static b2Transform`	`b2MulT(b2Transform A, b2Transform B)`
`static b2Vec2`	`b2MulT(b2Transform T, b2Vec2 v)`
`static long`	`b2NextPowerOfTwo(long x)` "Next Largest Power of 2 Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm that recursively "folds" the upper bits into the lower bits.
`static boolean`	`b2PairLessThan(b2Pair pair1, b2Pair pair2)` This is used to sort pairs.
`static b2ParticleColor`	`b2ParticleColor_zero()`
`static void`	`b2ParticleColor_zero(b2ParticleColor setter)`
`static void`	`b2SetAllocFreeCallbacks(b2AllocFunction allocCallback, b2FreeFunction freeCallback, Pointer callbackData)` Set alloc and free callbacks to override the default behavior of using malloc() and free() for dynamic memory allocation.
`static void`	`b2SetNumAllocs(int numAllocs)` Set the number of calls to b2Alloc minus the number of calls to b2Free.
`static boolean`	`b2TestOverlap(b2AABB a, b2AABB b)`
`static boolean`	`b2TestOverlap(b2Shape shapeA, int indexA, b2Shape shapeB, int indexB, b2Transform xfA, b2Transform xfB)` Determine if two generic shapes overlap.
`static void`	`b2TimeOfImpact(b2TOIOutput output, b2TOIInput input)` Compute the upper bound on time before two shapes penetrate.
`static b2Vec2`	`b2Vec2_zero()` Useful constant
`static b2Vec2`	`divide(b2Vec2 v, float f)` Divide a vector by a float.
`static boolean`	`equals(b2Vec2 a, b2Vec2 b)`
`static b2Vec2`	`multiply(b2Vec2 v, float f)` Multiply a float with a vector.
`static b2Vec2`	`multiply(float s, b2Vec2 a)`
`static b2Vec3`	`multiply(float s, b2Vec3 a)`
`static boolean`	`notEquals(b2Vec2 a, b2Vec2 b)`
`static b2Vec2`	`subtract(b2Vec2 a, b2Vec2 b)` Subtract two vectors component-wise.
`static b2Vec2`	`subtract(b2Vec2 v, float f)` Substract a float from a vector.
`static b2Vec3`	`subtract(b2Vec3 a, b2Vec3 b)` Subtract two vectors component-wise.

Methods inherited from class org.bytedeco.liquidfun.presets.liquidfun
map

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

Field Detail
- B2_ASSERT_ENABLED
```
public static final int B2_ASSERT_ENABLED
```
  See Also:
  
  Constant Field Values
- b2_pi
```
public static final double b2_pi
```
  See Also:
  
  Constant Field Values
- LIQUIDFUN_EXTERNAL_LANGUAGE_API
```
public static final int LIQUIDFUN_EXTERNAL_LANGUAGE_API
```
  See Also:
  
  Constant Field Values
- b2_maxManifoldPoints
```
public static final int b2_maxManifoldPoints
```
  The maximum number of contact points between two convex shapes. Do /** not change this value.
  
  See Also:
  
  Constant Field Values
- b2_maxPolygonVertices
```
public static final int b2_maxPolygonVertices
```
  The maximum number of vertices on a convex polygon. You cannot increase this too much because b2BlockAllocator has a maximum object size.
  
  See Also:
  
  Constant Field Values
- b2_aabbExtension
```
public static final double b2_aabbExtension
```
  This is used to fatten AABBs in the dynamic tree. This allows proxies to move by a small amount without triggering a tree adjustment. This is in meters.
  
  See Also:
  
  Constant Field Values
- b2_aabbMultiplier
```
public static final double b2_aabbMultiplier
```
  This is used to fatten AABBs in the dynamic tree. This is used to predict the future position based on the current displacement. This is a dimensionless multiplier.
  
  See Also:
  
  Constant Field Values
- b2_linearSlop
```
public static final double b2_linearSlop
```
  A small length used as a collision and constraint tolerance. Usually it is chosen to be numerically significant, but visually insignificant.
  
  See Also:
  
  Constant Field Values
- b2_angularSlop
```
public static final double b2_angularSlop
```
  A small angle used as a collision and constraint tolerance. Usually it is chosen to be numerically significant, but visually insignificant.
  
  See Also:
  
  Constant Field Values
- b2_polygonRadius
```
public static final double b2_polygonRadius
```
  The radius of the polygon/edge shape skin. This should not be modified. Making this smaller means polygons will have an insufficient buffer for continuous collision. Making it larger may create artifacts for vertex collision.
  
  See Also:
  
  Constant Field Values
- b2_maxSubSteps
```
public static final int b2_maxSubSteps
```
  Maximum number of sub-steps per contact in continuous physics simulation.
  
  See Also:
  
  Constant Field Values
- b2_maxTOIContacts
```
public static final int b2_maxTOIContacts
```
  Maximum number of contacts to be handled to solve a TOI impact.
  
  See Also:
  
  Constant Field Values
- b2_velocityThreshold
```
public static final double b2_velocityThreshold
```
  A velocity threshold for elastic collisions. Any collision with a relative linear velocity below this threshold will be treated as inelastic.
  
  See Also:
  
  Constant Field Values
- b2_maxLinearCorrection
```
public static final double b2_maxLinearCorrection
```
  The maximum linear position correction used when solving constraints. This helps to prevent overshoot.
  
  See Also:
  
  Constant Field Values
- b2_maxAngularCorrection
```
public static final double b2_maxAngularCorrection
```
  The maximum angular position correction used when solving constraints. This helps to prevent overshoot.
  
  See Also:
  
  Constant Field Values
- b2_maxTranslation
```
public static final double b2_maxTranslation
```
  The maximum linear velocity of a body. This limit is very large and is used to prevent numerical problems. You shouldn't need to adjust this.
  
  See Also:
  
  Constant Field Values
- b2_maxRotation
```
public static final double b2_maxRotation
```
  The maximum angular velocity of a body. This limit is very large and is used to prevent numerical problems. You shouldn't need to adjust this.
  
  See Also:
  
  Constant Field Values
- b2_baumgarte
```
public static final double b2_baumgarte
```
  This scale factor controls how fast overlap is resolved. Ideally this would be 1 so that overlap is removed in one time step. However using values close to 1 often lead to overshoot.
  
  See Also:
  
  Constant Field Values
- b2_toiBaugarte
```
public static final double b2_toiBaugarte
```
  See Also:
  
  Constant Field Values
- b2_invalidParticleIndex
```
public static final int b2_invalidParticleIndex
```
  A symbolic constant that stands for particle allocation error.
  
  See Also:
  
  Constant Field Values
- b2_maxParticleIndex
```
public static final int b2_maxParticleIndex
```
  See Also:
  
  Constant Field Values
- b2_particleStride
```
public static final double b2_particleStride
```
  The default distance between particles, multiplied by the particle diameter.
  
  See Also:
  
  Constant Field Values
- b2_minParticleWeight
```
public static final double b2_minParticleWeight
```
  The minimum particle weight that produces pressure.
  
  See Also:
  
  Constant Field Values
- b2_maxParticlePressure
```
public static final double b2_maxParticlePressure
```
  The upper limit for particle pressure.
  
  See Also:
  
  Constant Field Values
- b2_maxParticleForce
```
public static final double b2_maxParticleForce
```
  The upper limit for force between particles.
  
  See Also:
  
  Constant Field Values
- b2_maxTriadDistance
```
public static final int b2_maxTriadDistance
```
  The maximum distance between particles in a triad, multiplied by the particle diameter.
  
  See Also:
  
  Constant Field Values
- b2_maxTriadDistanceSquared
```
public static final int b2_maxTriadDistanceSquared
```
  See Also:
  
  Constant Field Values
- b2_minParticleSystemBufferCapacity
```
public static final int b2_minParticleSystemBufferCapacity
```
  The initial size of particle data buffers.
  
  See Also:
  
  Constant Field Values
- b2_barrierCollisionTime
```
public static final double b2_barrierCollisionTime
```
  The time into the future that collisions against barrier particles will be detected.
  
  See Also:
  
  Constant Field Values
- b2_timeToSleep
```
public static final double b2_timeToSleep
```
  The time that a body must be still before it will go to sleep.
  
  See Also:
  
  Constant Field Values
- b2_linearSleepTolerance
```
public static final double b2_linearSleepTolerance
```
  A body cannot sleep if its linear velocity is above this tolerance.
  
  See Also:
  
  Constant Field Values
- b2_angularSleepTolerance
```
public static final double b2_angularSleepTolerance
```
  A body cannot sleep if its angular velocity is above this tolerance.
  
  See Also:
  
  Constant Field Values
- B2_INTRUSIVE_LIST_VALIDATE
```
public static final int B2_INTRUSIVE_LIST_VALIDATE
```
  Normalize an angle in radians to be between -pi and pi
  
  See Also:
  
  Constant Field Values
- b2_nullState
```
public static final int b2_nullState
```
  enum b2PointState
  
  See Also:
  
  Constant Field Values
- b2_addState
```
public static final int b2_addState
```
  enum b2PointState
  
  See Also:
  
  Constant Field Values
- b2_persistState
```
public static final int b2_persistState
```
  enum b2PointState
  
  See Also:
  
  Constant Field Values
- b2_removeState
```
public static final int b2_removeState
```
  enum b2PointState
  
  See Also:
  
  Constant Field Values
- b2_nullNode
```
public static final int b2_nullNode
```
  See Also:
  
  Constant Field Values
- b2_staticBody
```
public static final int b2_staticBody
```
  enum b2BodyType
  
  See Also:
  
  Constant Field Values
- b2_kinematicBody
```
public static final int b2_kinematicBody
```
  enum b2BodyType
  
  See Also:
  
  Constant Field Values
- b2_dynamicBody
```
public static final int b2_dynamicBody
```
  enum b2BodyType
  
  See Also:
  
  Constant Field Values
- e_unknownJoint
```
public static final int e_unknownJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_revoluteJoint
```
public static final int e_revoluteJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_prismaticJoint
```
public static final int e_prismaticJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_distanceJoint
```
public static final int e_distanceJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_pulleyJoint
```
public static final int e_pulleyJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_mouseJoint
```
public static final int e_mouseJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_gearJoint
```
public static final int e_gearJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_wheelJoint
```
public static final int e_wheelJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_weldJoint
```
public static final int e_weldJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_frictionJoint
```
public static final int e_frictionJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_ropeJoint
```
public static final int e_ropeJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_motorJoint
```
public static final int e_motorJoint
```
  enum b2JointType
  
  See Also:
  
  Constant Field Values
- e_inactiveLimit
```
public static final int e_inactiveLimit
```
  enum b2LimitState
  
  See Also:
  
  Constant Field Values
- e_atLowerLimit
```
public static final int e_atLowerLimit
```
  enum b2LimitState
  
  See Also:
  
  Constant Field Values
- e_atUpperLimit
```
public static final int e_atUpperLimit
```
  enum b2LimitState
  
  See Also:
  
  Constant Field Values
- e_equalLimits
```
public static final int e_equalLimits
```
  enum b2LimitState
  
  See Also:
  
  Constant Field Values
- b2_waterParticle
```
public static final int b2_waterParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_zombieParticle
```
public static final int b2_zombieParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_wallParticle
```
public static final int b2_wallParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_springParticle
```
public static final int b2_springParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_elasticParticle
```
public static final int b2_elasticParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_viscousParticle
```
public static final int b2_viscousParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_powderParticle
```
public static final int b2_powderParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_tensileParticle
```
public static final int b2_tensileParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_colorMixingParticle
```
public static final int b2_colorMixingParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_destructionListenerParticle
```
public static final int b2_destructionListenerParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_barrierParticle
```
public static final int b2_barrierParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_staticPressureParticle
```
public static final int b2_staticPressureParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_reactiveParticle
```
public static final int b2_reactiveParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_repulsiveParticle
```
public static final int b2_repulsiveParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_fixtureContactListenerParticle
```
public static final int b2_fixtureContactListenerParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_particleContactListenerParticle
```
public static final int b2_particleContactListenerParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_fixtureContactFilterParticle
```
public static final int b2_fixtureContactFilterParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_particleContactFilterParticle
```
public static final int b2_particleContactFilterParticle
```
  enum b2ParticleFlag
  
  See Also:
  
  Constant Field Values
- b2_solidParticleGroup
```
public static final int b2_solidParticleGroup
```
  enum b2ParticleGroupFlag
  
  See Also:
  
  Constant Field Values
- b2_rigidParticleGroup
```
public static final int b2_rigidParticleGroup
```
  enum b2ParticleGroupFlag
  
  See Also:
  
  Constant Field Values
- b2_particleGroupCanBeEmpty
```
public static final int b2_particleGroupCanBeEmpty
```
  enum b2ParticleGroupFlag
  
  See Also:
  
  Constant Field Values
- b2_particleGroupWillBeDestroyed
```
public static final int b2_particleGroupWillBeDestroyed
```
  enum b2ParticleGroupFlag
  
  See Also:
  
  Constant Field Values
- b2_particleGroupNeedsUpdateDepth
```
public static final int b2_particleGroupNeedsUpdateDepth
```
  enum b2ParticleGroupFlag
  
  See Also:
  
  Constant Field Values
- b2_particleGroupInternalMask
```
public static final int b2_particleGroupInternalMask
```
  enum b2ParticleGroupFlag
  
  See Also:
  
  Constant Field Values

Constructor Detail
- liquidfun
```
public liquidfun()
```

Method Detail

b2Alloc

public static Pointer b2Alloc(@Cast(value="int32")
                              int size)

Implement this function to use your own memory allocator.

b2Free
```
public static void b2Free(Pointer mem)
```
If you implement b2Alloc, you should also implement this function.

b2SetAllocFreeCallbacks

public static void b2SetAllocFreeCallbacks(b2AllocFunction allocCallback,
                                           b2FreeFunction freeCallback,
                                           Pointer callbackData)

Set alloc and free callbacks to override the default behavior of using malloc() and free() for dynamic memory allocation. Set allocCallback and freeCallback to NULL to restore the default allocator (malloc / free).

b2SetNumAllocs
```
public static void b2SetNumAllocs(@Cast(value="const int32")
                                  int numAllocs)
```
Set the number of calls to b2Alloc minus the number of calls to b2Free. This can be used to disable the empty heap check in b2SetAllocFreeCallbacks() which can be useful for testing.

b2GetNumAllocs
```
@Cast(value="int32")
public static int b2GetNumAllocs()
```
Get number of calls to b2Alloc minus number of calls to b2Free.

b2Log

public static void b2Log(@Cast(value="const char*")
                         BytePointer string)

Logging function.

b2Log

public static void b2Log(String string)

b2_version
```
@ByRef
public static b2Version b2_version()
```
Current version. Version of Box2D, LiquidFun is based upon.

b2_version

public static void b2_version(b2Version setter)

b2_liquidFunVersion

@MemberGetter
 @Const
 @ByRef
public static b2Version b2_liquidFunVersion()

Global variable is used to identify the version of LiquidFun.

b2_liquidFunVersionString
```
@Cast(value="const char*")
public static BytePointer b2_liquidFunVersionString()
```
String which identifies the current version of LiquidFun. b2_liquidFunVersionString is used by Google developers to identify which applications uploaded to Google Play are using this library. This allows the development team at Google to determine the popularity of the library. How it works: Applications that are uploaded to the Google Play Store are scanned for this version string. We track which applications are using it to measure popularity. You are free to remove it (of course) but we would appreciate if you left it in.

b2_liquidFunVersionString

public static void b2_liquidFunVersionString(BytePointer setter)

b2IsValid

@Cast(value="bool")
public static boolean b2IsValid(@Cast(value="float32")
                                                     float x)

This function is used to ensure that a floating point number is not a NaN or infinity.

b2InvSqrt

@Cast(value="float32")
public static float b2InvSqrt(@Cast(value="float32")
                                                      float x)

This is a approximate yet fast inverse square-root.

add

@ByVal
 @Name(value="operator +")
public static b2Vec2 add(@Const @ByRef
                                                             b2Vec2 v,
                                                             float f)

Add a float to a vector.

subtract

@ByVal
 @Name(value="operator -")
public static b2Vec2 subtract(@Const @ByRef
                                                                  b2Vec2 v,
                                                                  float f)

Substract a float from a vector.

multiply

@ByVal
 @Name(value="operator *")
public static b2Vec2 multiply(@Const @ByRef
                                                                  b2Vec2 v,
                                                                  float f)

Multiply a float with a vector.

divide

@ByVal
 @Name(value="operator /")
public static b2Vec2 divide(@Const @ByRef
                                                                b2Vec2 v,
                                                                float f)

Divide a vector by a float.

b2Vec2_zero

@MemberGetter
 @Const
 @ByRef
public static b2Vec2 b2Vec2_zero()

Useful constant

b2Dot

@Cast(value="float32")
public static float b2Dot(@Const @ByRef
                                                  b2Vec2 a,
                                                  @Const @ByRef
                                                  b2Vec2 b)

Perform the dot product on two vectors.

b2Cross

@Cast(value="float32")
public static float b2Cross(@Const @ByRef
                                                    b2Vec2 a,
                                                    @Const @ByRef
                                                    b2Vec2 b)

Perform the cross product on two vectors. In 2D this produces a scalar.

b2Cross

@ByVal
public static b2Vec2 b2Cross(@Const @ByRef
                                     b2Vec2 a,
                                     @Cast(value="float32")
                                     float s)

Perform the cross product on a vector and a scalar. In 2D this produces a vector.

b2Cross

@ByVal
public static b2Vec2 b2Cross(@Cast(value="float32")
                                     float s,
                                     @Const @ByRef
                                     b2Vec2 a)

Perform the cross product on a scalar and a vector. In 2D this produces a vector.

b2Mul

@ByVal
public static b2Vec2 b2Mul(@Const @ByRef
                                   b2Mat22 A,
                                   @Const @ByRef
                                   b2Vec2 v)

Multiply a matrix times a vector. If a rotation matrix is provided, then this transforms the vector from one frame to another.

b2MulT

@ByVal
public static b2Vec2 b2MulT(@Const @ByRef
                                    b2Mat22 A,
                                    @Const @ByRef
                                    b2Vec2 v)

Multiply a matrix transpose times a vector. If a rotation matrix is provided, then this transforms the vector from one frame to another (inverse transform).

add

@ByVal
 @Name(value="operator +")
public static b2Vec2 add(@Const @ByRef
                                                             b2Vec2 a,
                                                             @Const @ByRef
                                                             b2Vec2 b)

Add two vectors component-wise.

subtract

@ByVal
 @Name(value="operator -")
public static b2Vec2 subtract(@Const @ByRef
                                                                  b2Vec2 a,
                                                                  @Const @ByRef
                                                                  b2Vec2 b)

Subtract two vectors component-wise.

multiply

@ByVal
 @Name(value="operator *")
public static b2Vec2 multiply(@Cast(value="float32")
                                                                  float s,
                                                                  @Const @ByRef
                                                                  b2Vec2 a)

equals

@Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                               b2Vec2 a,
                                                                               @Const @ByRef
                                                                               b2Vec2 b)

notEquals

@Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                  b2Vec2 a,
                                                                                  @Const @ByRef
                                                                                  b2Vec2 b)

b2Distance

@Cast(value="float32")
public static float b2Distance(@Const @ByRef
                                                       b2Vec2 a,
                                                       @Const @ByRef
                                                       b2Vec2 b)

b2DistanceSquared

@Cast(value="float32")
public static float b2DistanceSquared(@Const @ByRef
                                                              b2Vec2 a,
                                                              @Const @ByRef
                                                              b2Vec2 b)

multiply

@ByVal
 @Name(value="operator *")
public static b2Vec3 multiply(@Cast(value="float32")
                                                                  float s,
                                                                  @Const @ByRef
                                                                  b2Vec3 a)

add

@ByVal
 @Name(value="operator +")
public static b2Vec3 add(@Const @ByRef
                                                             b2Vec3 a,
                                                             @Const @ByRef
                                                             b2Vec3 b)

Add two vectors component-wise.

subtract

@ByVal
 @Name(value="operator -")
public static b2Vec3 subtract(@Const @ByRef
                                                                  b2Vec3 a,
                                                                  @Const @ByRef
                                                                  b2Vec3 b)

Subtract two vectors component-wise.

b2Dot

@Cast(value="float32")
public static float b2Dot(@Const @ByRef
                                                  b2Vec3 a,
                                                  @Const @ByRef
                                                  b2Vec3 b)

Perform the dot product on two vectors.

b2Cross

@ByVal
public static b2Vec3 b2Cross(@Const @ByRef
                                     b2Vec3 a,
                                     @Const @ByRef
                                     b2Vec3 b)

Perform the cross product on two vectors.

add

@ByVal
 @Name(value="operator +")
public static b2Mat22 add(@Const @ByRef
                                                              b2Mat22 A,
                                                              @Const @ByRef
                                                              b2Mat22 B)

b2Mul

@ByVal
public static b2Mat22 b2Mul(@Const @ByRef
                                    b2Mat22 A,
                                    @Const @ByRef
                                    b2Mat22 B)

b2MulT

@ByVal
public static b2Mat22 b2MulT(@Const @ByRef
                                     b2Mat22 A,
                                     @Const @ByRef
                                     b2Mat22 B)

b2Mul

@ByVal
public static b2Vec3 b2Mul(@Const @ByRef
                                   b2Mat33 A,
                                   @Const @ByRef
                                   b2Vec3 v)

Multiply a matrix times a vector.

b2Mul22

@ByVal
public static b2Vec2 b2Mul22(@Const @ByRef
                                     b2Mat33 A,
                                     @Const @ByRef
                                     b2Vec2 v)

Multiply a matrix times a vector.

b2Mul

@ByVal
public static b2Rot b2Mul(@Const @ByRef
                                  b2Rot q,
                                  @Const @ByRef
                                  b2Rot r)

Multiply two rotations: q * r

b2MulT

@ByVal
public static b2Rot b2MulT(@Const @ByRef
                                   b2Rot q,
                                   @Const @ByRef
                                   b2Rot r)

Transpose multiply two rotations: qT * r

b2Mul

@ByVal
public static b2Vec2 b2Mul(@Const @ByRef
                                   b2Rot q,
                                   @Const @ByRef
                                   b2Vec2 v)

Rotate a vector

b2MulT

@ByVal
public static b2Vec2 b2MulT(@Const @ByRef
                                    b2Rot q,
                                    @Const @ByRef
                                    b2Vec2 v)

Inverse rotate a vector

b2Mul

@ByVal
public static b2Vec2 b2Mul(@Const @ByRef
                                   b2Transform T,
                                   @Const @ByRef
                                   b2Vec2 v)

b2MulT

@ByVal
public static b2Vec2 b2MulT(@Const @ByRef
                                    b2Transform T,
                                    @Const @ByRef
                                    b2Vec2 v)

b2Mul

@ByVal
public static b2Transform b2Mul(@Const @ByRef
                                        b2Transform A,
                                        @Const @ByRef
                                        b2Transform B)

b2MulT

@ByVal
public static b2Transform b2MulT(@Const @ByRef
                                         b2Transform A,
                                         @Const @ByRef
                                         b2Transform B)

b2Abs

@ByVal
public static b2Vec2 b2Abs(@Const @ByRef
                                   b2Vec2 a)

b2Abs

@ByVal
public static b2Mat22 b2Abs(@Const @ByRef
                                    b2Mat22 A)

b2Min

@ByVal
public static b2Vec2 b2Min(@Const @ByRef
                                   b2Vec2 a,
                                   @Const @ByRef
                                   b2Vec2 b)

b2Max

@ByVal
public static b2Vec2 b2Max(@Const @ByRef
                                   b2Vec2 a,
                                   @Const @ByRef
                                   b2Vec2 b)

b2Clamp

@ByVal
public static b2Vec2 b2Clamp(@Const @ByRef
                                     b2Vec2 a,
                                     @Const @ByRef
                                     b2Vec2 low,
                                     @Const @ByRef
                                     b2Vec2 high)

b2NextPowerOfTwo
```
@Cast(value="uint32")
public static long b2NextPowerOfTwo(@Cast(value="uint32")
                                                           long x)
```
"Next Largest Power of 2 Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next largest power of 2. For a 32-bit value:"

b2IsPowerOfTwo

@Cast(value="bool")
public static boolean b2IsPowerOfTwo(@Cast(value="uint32")
                                                          long x)

b2_nullFeature
```
@MemberGetter
 @Cast(value="const uint8")
public static short b2_nullFeature()
```
\file Structures and functions used for computing contact points, distance queries, and TOI queries.

b2GetPointStates

public static void b2GetPointStates(@Cast(value="b2PointState*")
                                    IntPointer state1,
                                    @Cast(value="b2PointState*")
                                    IntPointer state2,
                                    @Const
                                    b2Manifold manifold1,
                                    @Const
                                    b2Manifold manifold2)

Compute the point states given two manifolds. The states pertain to the transition from manifold1 to manifold2. So state1 is either persist or remove while state2 is either add or persist.

b2GetPointStates

public static void b2GetPointStates(@Cast(value="b2PointState*")
                                    IntBuffer state1,
                                    @Cast(value="b2PointState*")
                                    IntBuffer state2,
                                    @Const
                                    b2Manifold manifold1,
                                    @Const
                                    b2Manifold manifold2)

b2GetPointStates

public static void b2GetPointStates(@Cast(value="b2PointState*")
                                    int[] state1,
                                    @Cast(value="b2PointState*")
                                    int[] state2,
                                    @Const
                                    b2Manifold manifold1,
                                    @Const
                                    b2Manifold manifold2)

b2CollideCircles

public static void b2CollideCircles(b2Manifold manifold,
                                    @Const
                                    b2CircleShape circleA,
                                    @Const @ByRef
                                    b2Transform xfA,
                                    @Const
                                    b2CircleShape circleB,
                                    @Const @ByRef
                                    b2Transform xfB)

Compute the collision manifold between two circles.

b2CollidePolygonAndCircle

public static void b2CollidePolygonAndCircle(b2Manifold manifold,
                                             @Const
                                             b2PolygonShape polygonA,
                                             @Const @ByRef
                                             b2Transform xfA,
                                             @Const
                                             b2CircleShape circleB,
                                             @Const @ByRef
                                             b2Transform xfB)

Compute the collision manifold between a polygon and a circle.

b2CollidePolygons

public static void b2CollidePolygons(b2Manifold manifold,
                                     @Const
                                     b2PolygonShape polygonA,
                                     @Const @ByRef
                                     b2Transform xfA,
                                     @Const
                                     b2PolygonShape polygonB,
                                     @Const @ByRef
                                     b2Transform xfB)

Compute the collision manifold between two polygons.

b2CollideEdgeAndCircle

public static void b2CollideEdgeAndCircle(b2Manifold manifold,
                                          @Const
                                          b2EdgeShape polygonA,
                                          @Const @ByRef
                                          b2Transform xfA,
                                          @Const
                                          b2CircleShape circleB,
                                          @Const @ByRef
                                          b2Transform xfB)

Compute the collision manifold between an edge and a circle.

b2CollideEdgeAndPolygon

public static void b2CollideEdgeAndPolygon(b2Manifold manifold,
                                           @Const
                                           b2EdgeShape edgeA,
                                           @Const @ByRef
                                           b2Transform xfA,
                                           @Const
                                           b2PolygonShape circleB,
                                           @Const @ByRef
                                           b2Transform xfB)

Compute the collision manifold between an edge and a circle.

b2ClipSegmentToLine

@Cast(value="int32")
public static int b2ClipSegmentToLine(b2ClipVertex vOut,
                                                            @Const
                                                            b2ClipVertex vIn,
                                                            @Const @ByRef
                                                            b2Vec2 normal,
                                                            @Cast(value="float32")
                                                            float offset,
                                                            @Cast(value="int32")
                                                            int vertexIndexA)

Clipping for contact manifolds.

b2TestOverlap

@Cast(value="bool")
public static boolean b2TestOverlap(@Const
                                                         b2Shape shapeA,
                                                         @Cast(value="int32")
                                                         int indexA,
                                                         @Const
                                                         b2Shape shapeB,
                                                         @Cast(value="int32")
                                                         int indexB,
                                                         @Const @ByRef
                                                         b2Transform xfA,
                                                         @Const @ByRef
                                                         b2Transform xfB)

Determine if two generic shapes overlap.

b2TestOverlap

@Cast(value="bool")
public static boolean b2TestOverlap(@Const @ByRef
                                                         b2AABB a,
                                                         @Const @ByRef
                                                         b2AABB b)

b2PairLessThan

@Cast(value="bool")
public static boolean b2PairLessThan(@Const @ByRef
                                                          b2Pair pair1,
                                                          @Const @ByRef
                                                          b2Pair pair2)

This is used to sort pairs.

b2Distance

public static void b2Distance(b2DistanceOutput output,
                              b2SimplexCache cache,
                              @Const
                              b2DistanceInput input)

Compute the closest points between two shapes. Supports any combination of: b2CircleShape, b2PolygonShape, b2EdgeShape. The simplex cache is input/output. On the first call set b2SimplexCache.count to zero.

b2TimeOfImpact
```
public static void b2TimeOfImpact(b2TOIOutput output,
                                  @Const
                                  b2TOIInput input)
```
Compute the upper bound on time before two shapes penetrate. Time is represented as a fraction between [0,tMax]. This uses a swept separating axis and may miss some intermediate, non-tunneling collision. If you change the time interval, you should call this function again. Note: use b2Distance to compute the contact point and normal at the time of impact.

b2MixFriction

@Cast(value="float32")
public static float b2MixFriction(@Cast(value="float32")
                                                          float friction1,
                                                          @Cast(value="float32")
                                                          float friction2)

Friction mixing law. The idea is to allow either fixture to drive the restitution to zero. For example, anything slides on ice.

b2MixRestitution

@Cast(value="float32")
public static float b2MixRestitution(@Cast(value="float32")
                                                             float restitution1,
                                                             @Cast(value="float32")
                                                             float restitution2)

Restitution mixing law. The idea is allow for anything to bounce off an inelastic surface. For example, a superball bounces on anything.

b2_minPulleyLength

@MemberGetter
 @Cast(value="const float32")
public static float b2_minPulleyLength()

b2ParticleColor_zero

@ByRef
public static b2ParticleColor b2ParticleColor_zero()

b2ParticleColor_zero

public static void b2ParticleColor_zero(b2ParticleColor setter)

b2CalculateParticleIterations

@Cast(value="int32")
public static int b2CalculateParticleIterations(@Cast(value="float32")
                                                                      float gravity,
                                                                      @Cast(value="float32")
                                                                      float radius,
                                                                      @Cast(value="float32")
                                                                      float timeStep)

A helper function to calculate the optimal number of iterations.

Class liquidfun

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.liquidfun.presets.liquidfun

Methods inherited from class java.lang.Object

Field Detail

B2_ASSERT_ENABLED

b2_pi

LIQUIDFUN_EXTERNAL_LANGUAGE_API

b2_maxManifoldPoints

b2_maxPolygonVertices

b2_aabbExtension

b2_aabbMultiplier

b2_linearSlop

b2_angularSlop

b2_polygonRadius

b2_maxSubSteps

b2_maxTOIContacts

b2_velocityThreshold

b2_maxLinearCorrection

b2_maxAngularCorrection

b2_maxTranslation

b2_maxRotation

b2_baumgarte

b2_toiBaugarte

b2_invalidParticleIndex

b2_maxParticleIndex

b2_particleStride

b2_minParticleWeight

b2_maxParticlePressure

b2_maxParticleForce

b2_maxTriadDistance

b2_maxTriadDistanceSquared

b2_minParticleSystemBufferCapacity

b2_barrierCollisionTime

b2_timeToSleep

b2_linearSleepTolerance

b2_angularSleepTolerance

B2_INTRUSIVE_LIST_VALIDATE

b2_nullState

b2_addState

b2_persistState

b2_removeState

b2_nullNode

b2_staticBody

b2_kinematicBody

b2_dynamicBody

e_unknownJoint

e_revoluteJoint

e_prismaticJoint

e_distanceJoint

e_pulleyJoint

e_mouseJoint

e_gearJoint

e_wheelJoint

e_weldJoint

e_frictionJoint

e_ropeJoint

e_motorJoint

e_inactiveLimit

e_atLowerLimit

e_atUpperLimit

e_equalLimits

b2_waterParticle

b2_zombieParticle

b2_wallParticle

b2_springParticle

b2_elasticParticle

b2_viscousParticle

b2_powderParticle

b2_tensileParticle

b2_colorMixingParticle

b2_destructionListenerParticle

b2_barrierParticle

b2_staticPressureParticle

b2_reactiveParticle

b2_repulsiveParticle

b2_fixtureContactListenerParticle

b2_particleContactListenerParticle