# 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.

## Ptr<JointCylindrical> cast( const Ptr<Joint> & joint )

Casts a JointCylindrical out of the Joint instance.### Arguments

*const Ptr<Joint> &***joint**- Joint instance.

### Return value

JointCylindrical.## 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:
2019-04-30

Help improve this article

Was this article helpful?

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