# Unigine::JointCylindrical Class

Header: | #include <UniginePhysics.h> |

Inherits: | Joint |

This class is used to create cylindrical joints.

### Example*#*

The following code illustrates connection of two bodies (b0 and b1) using a cylindrical joint.

```
include <UniginePhysics.h>
/* .. */
JointCylindricalPtr joint = JointCylindrical::create(b0, b1);
// setting joint axis coordinates
joint->setWorldAxis(vec3(0.0f, 0.0f, 1.0f));
// setting common joint constraint parameters
joint->setLinearRestitution(0.4f);
joint->setAngularRestitution(0.4f);
joint->setLinearSoftness(0.4f);
joint->setAngularSoftness(0.4f);
// setting linear and angular damping
joint->setLinearDamping(4.0f);
joint->setAngularDamping(2.0f);
// setting linear limits [-1.5; 1.5]
joint->setLinearLimitFrom(-1.5f);
joint->setLinearLimitTo(1.5f);
// setting number of iterations
joint->setNumIterations(16);
```

### See Also*#*

Usage examples:

- Creating a Simple Mechanism Using Various Types of Joints.
- A set of UnigineScript API samples located in the <UnigineSDK>/data/samples/joints/ folder:
- cylindrical_00
- cylindrical_01

## JointCylindrical Class

### Members

## static JointCylindricalPtr
create
(
)
*#*

Constructor. Creates a cylindrical joint with an anchor at the origin of the world coordinates.## static JointCylindricalPtr
create
(
const Ptr<Body> & body0, const Ptr<Body> & body1
)
*#*

Constructor. Creates a cylindrical joint connecting two given bodies. An anchor is placed between centers of mass of the bodies.### Arguments

*const Ptr<Body> &***body0**- First body to be connected with the joint.*const Ptr<Body> &***body1**- Second body to be connected with the joint.

## static JointCylindricalPtr
create
(
const Ptr<Body> & body0, const Ptr<Body> & body1, const Math::Vec3 & anchor, const Math::vec3 & axis
)
*#*

Constructor. Creates a cylindrical joint connecting two given bodies with specified axis coordinates and an anchor placed at specified coordinates.### Arguments

*const Ptr<Body> &***body0**- First body to be connected with the joint.*const Ptr<Body> &***body1**- Second body to be connected with the joint.*const Math::Vec3 &***anchor**- Anchor coordinates.*const Math::vec3 &***axis**- Axis coordinates.

## void setAngularAngle
(
float angle
)
*#*

Sets a target angle of the attached angular spring. The spring tries to rotate the connected bodies so that they make this angle.### Arguments

*float***angle**- Angle in degrees. The provided value will be saturated in the range**[-180; 180]**.

## float getAngularAngle
(
)
*#*

Returns the target angle of the attached angular spring. The spring tries to rotate the connected bodies so that they make this angle.### Return value

Target angle in degrees.## void setAngularDamping
(
float damping
)
*#*

Sets an angular damping of the joint.### Arguments

*float***damping**- Angular damping. If a negative value is provided,**0**will be used instead.

## float getAngularDamping
(
)
*#*

Returns the angular damping of the joint.### Return value

Angular damping.## void setAngularLimitFrom
(
float from
)
*#*

Sets a low rotation limit angle. Rotation limit specifies how much a connected body can rotate around the joint axis.### Arguments

*float***from**- Angle in degrees. The provided value will be saturated in the range**[-180; 180]**.

## float getAngularLimitFrom
(
)
*#*

Returns the low rotation limit angle. Rotation limit specifies how much a connected body can rotate around the joint axis.### Return value

Low rotation limit angle in degrees.## void setAngularLimitTo
(
float to
)
*#*

Sets a high rotation limit angle. Rotation limit specifies how much a connected body can rotate around the joint axis.### Arguments

*float***to**- Angle in degrees. The provided value will be saturated in the range**[-180; 180]**.

## float getAngularLimitTo
(
)
*#*

Returns the high rotation limit angle. Rotation limit specifies how much a connected body can rotate around the joint axis### Return value

High rotation limit angle in degrees.## void setAngularSpring
(
float spring
)
*#*

Sets a rigidity coefficient of the angular spring.### Arguments

*float***spring**- Rigidity coefficient. If a negative value is provided,**0**will be used instead.**0**detaches the spring.

## float getAngularSpring
(
)
*#*

Returns the rigidity coefficient of the angular spring. **0**means that the spring is not attached.

### Return value

Rigidity coefficient.## void setAngularTorque
(
float torque
)
*#*

Sets a maximum torque of the angular motor.### Arguments

*float***torque**- Maximum torque. If a negative value is provided,**0**will be used instead.**0**detaches the motor.

## float getAngularTorque
(
)
*#*

Returns the maximum torque of the attached angular motor. **0**means that the motor is not attached.

### Return value

Maximum torque.## void setAngularVelocity
(
float velocity
)
*#*

Sets a target velocity of the attached angular motor.### Arguments

*float***velocity**- Velocity in radians per second.

## float getAngularVelocity
(
)
*#*

Returns the target velocity of the attached angular motor.### Return value

Target velocity in radians per second.## void setAxis0
(
const Math::vec3 & axis0
)
*#*

Sets an axis of the first connected body.### Arguments

*const Math::vec3 &***axis0**- Axis of the first body. The provided vector will be normalized.

## Math::vec3 getAxis0
(
)
*#*

Returns the axis of the first connected body.### Return value

Axis of the first body.## void setAxis1
(
const Math::vec3 & axis1
)
*#*

Sets an axis of the second connected body.### Arguments

*const Math::vec3 &***axis1**- Axis of the second body. The provided vector will be normalized.

## Math::vec3 getAxis1
(
)
*#*

Returns the axis of the second connected body.### Return value

Axis of the second body.## float getCurrentAngularAngle
(
)
*#*

Returns the current angle between the bodies.### Return value

Current angle in degrees.## float getCurrentAngularVelocity
(
)
*#*

Returns the current velocity of the angular motor.### Return value

Current velocity in radians per second.## float getCurrentLinearDistance
(
)
*#*

Returns the current distance between the bodies.### Return value

Current distance in units.## float getCurrentLinearVelocity
(
)
*#*

Returns the current velocity of the linear motor.### Return value

Current velocity in units per second.## void setLinearDamping
(
float damping
)
*#*

Sets a linear damping of the joint.### Arguments

*float***damping**- Linear damping. If a negative value is provided,**0**will be used instead.

## float getLinearDamping
(
)
*#*

Returns the linear damping of the joint.### Return value

Linear damping.## void setLinearDistance
(
float distance
)
*#*

Sets a target distance of the attached linear spring. The spring tries to move the connected bodies so that to keep this distance between them.### Arguments

*float***distance**- Target distance in units.

## float getLinearDistance
(
)
*#*

Returns the target distance of the attached linear spring. The spring tries to move the connected bodies so that to keep this distance between them.### Return value

Target distance in units.## void setLinearForce
(
float force
)
*#*

Sets a maximum force of the attached linear motor.### Arguments

*float***force**- Maximum force. If a negative value is provided,**0**will be used instead.**0**detaches the motor.

## float getLinearForce
(
)
*#*

Returns the maximum force of the attached linear motor. **0**means that the motor is not attached.

### Return value

Maximum force.## void setLinearLimitFrom
(
float from
)
*#*

Sets a low limit distance. This limit specifies how far a connected body can move along the joint axis.### Arguments

*float***from**- Distance in units.

## float getLinearLimitFrom
(
)
*#*

Returns the low limit distance. This limit specifies how far a connected body can move along the joint axis.### Return value

Low limit distance in units.## void setLinearLimitTo
(
float to
)
*#*

Sets a high limit distance. This limit specifies how far a connected body can move along the joint axis.### Arguments

*float***to**- Distance in units.

## float getLinearLimitTo
(
)
*#*

Returns the high limit distance. This limit specifies how far a connected body can move along the joint axis.### Return value

High limit distance in units.## void setLinearSpring
(
float spring
)
*#*

Sets a rigidity coefficient of the linear spring.### Arguments

*float***spring**- Rigidity coefficient. If a negative value is provided,**0**will be used instead.**0**detaches the spring.

## float getLinearSpring
(
)
*#*

Returns the rigidity coefficient of the linear spring. **0**means that the spring is not attached.

### Return value

Rigidity coefficient.## void setLinearVelocity
(
float velocity
)
*#*

Sets a target velocity of the attached linear motor.### Arguments

*float***velocity**- Target velocity in units per second.

## float getLinearVelocity
(
)
*#*

Returns the target velocity of the attached linear motor.### Return value

Target velocity in units per second.## void setWorldAxis
(
const Math::vec3 & axis
)
*#*

Sets a joint axis. This method updates axes of the connected bodies.### Arguments

*const Math::vec3 &***axis**- Joint axis.

## Math::vec3 getWorldAxis
(
)
*#*

Returns the joint axis. The joint axis is calculated based on the axes of the connected bodies.### Return value

Joint axis.Last update:
2020-04-10

Help improve this article

Was this article helpful?

(or select a word/phrase and press Ctrl+Enter)