# Unigine::Shape Class

Header: | #include <UniginePhysics.h> |

This class creates collision shapes that approximate the finite volume of physical bodies and allow them to collide. Shapes are assigned to a body and are positioned in its local coordinates.

## Shape Class

### Members

## Math::vec3 getArea()

Returns areas of shape projections on three axes:*x*,

*y*, and

*z*.

### Return value

A triple of projection areas.## void setBody(const Ptr<Body> & body)

Sets a body, to which the shape belongs.### Arguments

*const Ptr<Body> &***body**- Body, to which the shape belongs.

## Ptr<Body> getBody()

Returns the body, to which the shape belongs.### Return value

Body, to which the shape belongs.## Math::vec3 getCenterOfMass()

Returns local coordinates of the center of mass of the shape.### Return value

Coordinates of the center of mass.## void setCollisionMask(int mask)

Sets a collision mask for the shape. Two objects collide if they both have matching masks. See also details on additional collision exclusion mask.### Arguments

*int***mask**- Integer, each bit of which is a mask.

## int getCollisionMask()

Returns the collision mask of the actor. Two objects collide if they both have matching masks.See also details on additional collision exclusion mask.### Return value

Integer, each bit of which is a mask.## void setContinuous(int continuous)

Enables or disables continuous collision detection for spheres or capsules. Enabled CDD incurs almost no performance penalty. Disabling CCD allows to avoid physics artifacts, if there are any.### Arguments

*int***continuous**- Positive value to enable CCD;**0**to disable.

## int isContinuous()

Returns a value indicating if continuous collision detection for spheres or capsules is enabled. Enabled CCD incurs almost no performance penalty. Disabling CCD allows to avoid physics artifacts, if there are any.### Return value

**1**if CCD is enabled; otherwise,

**0**.

## void setDensity(float density)

Sets density of a shape. Changing the density influences the mass, that is computed by multiplying shape volume by density.### Arguments

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

## float getDensity()

Returns the current density of a shape.### Return value

Density value.## void setEnabled(int enable)

Enables or disables physical interactions with the shape.### Arguments

*int***enable**- Positive number to enable physical interactions,**0**to disable them.

## int isEnabled()

Returns a value indicating if physical interactions with the shape are enabled.### Return value

**1**if physical interactions with the shape are enabled; otherwise,

**0**.

## int isEnabledSelf()

Returns a value indicating if the shape is enabled.### Return value

1 if the shape is enabled; otherwise, 0.## void setExclusionMask(int mask)

Sets an bit mask to prevent collisions of the shape with other ones. This mask is independent of the collision mask. For shapes with matching collision masks not to collide, at least one bit of their exclusion mask should match.### Arguments

*int***mask**- Integer, each bit of which is a mask.

## int getExclusionMask()

Returns the bit mask that prevents collisions of the shape with other ones. This mask is independent of the collision mask. For shape with matching collision masks not to collide, at least one bit of their exclusion mask should match.### Return value

Integer, each bit of which is a mask.## void setFriction(float friction)

Sets a friction of the shape surface.### Arguments

*float***friction**- Friction of the shape surface. If a negative value is provided,**0**will be used instead.

## float getFriction()

Returns the friction of the shape surface.### Return value

Friction of the shape surface.## int setID(int id)

Sets the unique ID for the shape.### Arguments

*int***id**- Unique ID.

### Return value

1 if the ID is set successfully; otherwise, 0.## int getID()

Returns the unique ID of the shape.### Return value

Unique ID.## Math::mat3 getInertia()

## int getIntersection(const Math::Vec3 & p0, const Math::Vec3 & p1, const Ptr<PhysicsIntersectionNormal> & intersection)

Performs tracing from the p0 point to the p1 point to find a shape located on that line. Intersection is found only for objects with a matching mask.

Depending on the variable passed as an argument, the result can be presented as the PhysicsIntersection or PhysicsIntersectionNormal node.

**Usage Example**

The following example shows how you can get the intersection information by using the PhysicsIntersection class. In this example the line is an invisible traced line from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1). It is supposed that you have a shape in your world. The executing sequence is the following:

- Define and initialize two points (p0 and p1) by using the
*getPlayerMouseDirection()*function from core/scripts/utils.h. - Create an instance of the PhysicsIntersection class to get the information of the intersection point.
- Check, if there is a intersection with a shape and save the result in the int variable.
- In this example, if there is an intersection of mouse direction with a specific shape called "shape", the PhysicsIntersection class instance gets the and intersection point and show the result in console.

```
#include <core/scripts/utils.h>
/* ... */
// define two vec3 coordinates
vec3 p0,p1;
// get the mouse direction from camera (p0) to cursor pointer (p1)
getPlayerMouseDirection(p0,p1);
// create the instance of the PhysicsIntersection object to save the information about the intersection
PhysicsIntersection intersection = new PhysicsIntersection();
// create an int varaible to check the result of intersection
int result;
result = shape2.getIntersection(p0, p1, intersection);
// if there was an intersection, show the message in console
if(result != 0)
{
log.message("intersection point: %s \n", typeinfo(intersection.getPoint()) );
}
/* ... */
```

### Arguments

*const Math::Vec3 &***p0**- Start point of the line.*const Math::Vec3 &***p1**- End point of the line.*const Ptr<PhysicsIntersectionNormal> &***intersection**- Intersection mask.

### Return value

Reference to the first intersected shape, if found; otherwise - 0.## int getIntersection(const Math::Vec3 & p0, const Math::Vec3 & p1, const Ptr<PhysicsIntersection> & intersection)

Performs tracing from the p0 point to the p1 point to find a shape located on that line. Intersection is found only for objects with a matching mask.

Depending on the variable passed as an argument, the result can be presented as the PhysicsIntersection or PhysicsIntersectionNormal node.

**Usage Example**

The following example shows how you can get the intersection information by using the PhysicsIntersection class. In this example the line is an invisible traced line from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1). It is supposed that you have a shape in your world. The executing sequence is the following:

- Define and initialize two points (p0 and p1) by using the
*getPlayerMouseDirection()*function from core/scripts/utils.h. - Create an instance of the PhysicsIntersection class to get the information of the intersection point.
- Check, if there is a intersection with a shape and save the result in the int variable.
- In this example, if there is an intersection of mouse direction with a specific shape called "shape", the PhysicsIntersection class instance gets the and intersection point and show the result in console.

```
#include <core/scripts/utils.h>
/* ... */
// define two vec3 coordinates
vec3 p0,p1;
// get the mouse direction from camera (p0) to cursor pointer (p1)
getPlayerMouseDirection(p0,p1);
// create the instance of the PhysicsIntersection object to save the information about the intersection
PhysicsIntersection intersection = new PhysicsIntersection();
// create an int varaible to check the result of intersection
int result;
result = shape2.getIntersection(p0, p1, intersection);
// if there was an intersection, show the message in console
if(result != 0)
{
log.message("intersection point: %s \n", typeinfo(intersection.getPoint()) );
}
/* ... */
```

### Arguments

*const Math::Vec3 &***p0**- Start point of the line.*const Math::Vec3 &***p1**- End point of the line.*const Ptr<PhysicsIntersection> &***intersection**- Intersection mask.

### Return value

Reference to the first intersected shape, if found; otherwise - 0.## int getIntersection(const Math::Vec3 & p0, const Math::Vec3 & p1, Math::Vec3 * ret_point, Math::vec3 * ret_normal)

Performs tracing from the p0 point to the p1 point to find a shape located on that line. Intersection is found only for objects with a matching mask.

Depending on the variable passed as an argument, the result can be presented as the PhysicsIntersection or PhysicsIntersectionNormal node.

**Usage Example**

The following example shows how you can get the intersection information by using the PhysicsIntersection class. In this example the line is an invisible traced line from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1). It is supposed that you have a shape in your world. The executing sequence is the following:

- Define and initialize two points (p0 and p1) by using the
*getPlayerMouseDirection()*function from core/scripts/utils.h. - Create an instance of the PhysicsIntersection class to get the information of the intersection point.
- Check, if there is a intersection with a shape and save the result in the int variable.
- In this example, if there is an intersection of mouse direction with a specific shape called "shape", the PhysicsIntersection class instance gets the and intersection point and show the result in console.

```
#include <core/scripts/utils.h>
/* ... */
// define two vec3 coordinates
vec3 p0,p1;
// get the mouse direction from camera (p0) to cursor pointer (p1)
getPlayerMouseDirection(p0,p1);
// create the instance of the PhysicsIntersection object to save the information about the intersection
PhysicsIntersection intersection = new PhysicsIntersection();
// create an int varaible to check the result of intersection
int result;
result = shape2.getIntersection(p0, p1, intersection);
// if there was an intersection, show the message in console
if(result != 0)
{
log.message("intersection point: %s \n", typeinfo(intersection.getPoint()) );
}
/* ... */
```

### Arguments

*const Math::Vec3 &***p0**- Start point of the line.*const Math::Vec3 &***p1**- End point of the line.*Math::Vec3 ****ret_point**- Intersection mask.*Math::vec3 ****ret_normal**- Variable defining which type of intersection object will be returned:- PhysicsIntersectionintersection- ThePhysicsIntersection class instance.
- PhysicsIntersectionNormalnormal- ThePhysicsIntersectionNormal class instance.

### Return value

Reference to the first intersected shape, if found; otherwise - 0.## void setIntersectionMask(int mask)

Sets an intersection mask for the shape.### Arguments

*int***mask**- Integer, each bit of which is a mask.

## int getIntersectionMask()

Returns an intersection mask of the joint.### Return value

Integer, each bit of which is a mask.## void setMass(float mass)

Sets a mass of the shape. Changing the mass influences the density, that is computed by dividing the mass by shape volume.*g*(Earth's gravity) equals to 9.8 m/s

^{2}, and 1 unit equals to 1 m, a shape with mass value of

**1**weighs 1 kg.

### Arguments

*float***mass**- Mass of the shape. If a negative value is provided,**0**will be used instead.

## float getMass()

Returns the mass of the shape.*g*(Earth's gravity) equals to 9.8 m/s

^{2}, and 1 unit equals to 1 m, the mass is measured in kilograms.

### Return value

Mass of the shape.## void setName(const char * name)

Sets the name of the shape.### Arguments

*const char ****name**- Name of the shape.

## const char * getName()

Returns the name of the shape.### Return value

Name of the shape.## void setRestitution(float restitution)

Sets a restitution of the shape surface.### Arguments

*float***restitution**- Restitution of the shape surface. The provided value will be saturated in the range**[0; 1]**.

## float getRestitution()

Returns the restitution of the shape surface.### Return value

Restitution of the shape surface.## Ptr<Shape> getShape()

## int getType()

Returns the type of the shape.### Return value

One of the*SHAPE_**pre-defined variables.

## const char * getTypeName()

Returns the name of the shape type.### Return value

Type name.## float getVolume()

Returns the volume of the shape.### Return value

Volume of the shape in cubic units.## Ptr<Shape> clone()

Clones the shape.### Return value

Copy of the shape.## void renderVisualizer(const Math::vec4 & color)

Renders the shape.**show_visualizer 1**console command.

### Arguments

*const Math::vec4 &***color**- Color, in which the shape will be rendered.

## int restoreState(const Ptr<Stream> & stream)

Restores the state of a given node from a binary stream.- If a node is a parent for other nodes, states of these child nodes need to be restored manually.
- To save the state into a buffer, file or a message from a socket, make sure the stream is opened. If necessary, you can set a position for writing for buffers and files.

### Arguments

*const Ptr<Stream> &***stream**- Stream with saved node state data.

### Return value

**1**if node state is successfully restored; otherwise,

**0**.

## int saveState(const Ptr<Stream> & stream)

Saves the state of a given node into a binary stream.- If a node is a parent for other nodes, states of these child nodes need to be saved manually.
- To save the state from a buffer, file or a message from a socket, make sure the stream is opened. For buffers and files, you also need to set the proper position for reading.

### Arguments

*const Ptr<Stream> &***stream**- Stream to save node state data.

### Return value

**1**if node state is successfully saved; otherwise,

**0**.

## void swap(const Ptr<Shape> & shape)

Swaps the shapes saving the pointers.### Arguments

*const Ptr<Shape> &***shape**- A shape to swap.