### Setup and Usage of KinematicCharacterController in Bevy Rapier (3D)

Source: https://www.rapier.rs/docs/user_guides/bevy_plugin/character_controller

Illustrates the setup and usage of the KinematicCharacterController for 3D physics in Bevy Rapier. This example includes physics setup, system for updating the controller's translation based on time delta, and a system for reading movement results. It requires a Transform component for the entity.

```rust
fn setup_physics(mut commands: Commands) {
    commands
        .spawn(RigidBody::KinematicPositionBased)
        .insert(Collider::ball(0.5))
        .insert(Transform::default())
        .insert(KinematicCharacterController {
            ..KinematicCharacterController::default()
        });
}

fn update_system(time: Res<Time>, mut controllers: Query<&mut KinematicCharacterController>) {
    for mut controller in controllers.iter_mut() {
        controller.translation = Some(Vec3::new(1.0, -5.0, -1.0) * time.delta_secs());
    }
}

fn read_result_system(controllers: Query<(Entity, &KinematicCharacterControllerOutput)>) {
    for (entity, output) in controllers.iter() {
        println!(
            "Entity {:?} moved by {:?} and touches the ground: ?",
            entity, output.effective_translation, output.grounded
        );
    }
}

```

--------------------------------

### Install Rapier 3D via NPM

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Adds the Rapier 3D physics engine to your project's dependencies in package.json. Replace '*' with the latest version number for stable integration.

```json
"dependencies": {
    "@dimforge/rapier3d": "*"  // Replace the * by the latest version number.
  }
```

--------------------------------

### Install Rapier 2D via NPM

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Adds the Rapier 2D physics engine to your project's dependencies in package.json. Replace '*' with the latest version number for stable integration.

```json
"dependencies": {
    "@dimforge/rapier2d": "*"  // Replace the * by the latest version number.
  }
```

--------------------------------

### Initialize Rapier 3D Physics World with Bundler

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Demonstrates asynchronous initialization of the Rapier 3D WebAssembly module. It sets up a basic physics world with gravity, a ground, and a dynamic rigid body, then runs a simple game loop to simulate physics.

```javascript
import('@dimforge/rapier3d').then(RAPIER => {
    // Use the RAPIER module here.
    let gravity = { x: 0.0, y: -9.81, z: 0.0 };
    let world = new RAPIER.World(gravity);

    // Create the ground
    let groundColliderDesc = RAPIER.ColliderDesc.cuboid(10.0, 0.1, 10.0);
    world.createCollider(groundColliderDesc);

    // Create a dynamic rigid-body.
    let rigidBodyDesc = RAPIER.RigidBodyDesc.dynamic()
        .setTranslation(0.0, 1.0, 0.0);
    let rigidBody = world.createRigidBody(rigidBodyDesc);

    // Create a cuboid collider attached to the dynamic rigidBody.
    let colliderDesc = RAPIER.ColliderDesc.cuboid(0.5, 0.5, 0.5);
    let collider = world.createCollider(colliderDesc, rigidBody);

    // Game loop. Replace by your own game loop system.
    let gameLoop = () => {
        // Step the simulation forward.    
        world.step();

        // Get and print the rigid-body's position.
        let position = rigidBody.translation();
        console.log("Rigid-body position: ", position.x, position.y);

        setTimeout(gameLoop, 16);
    };

    gameLoop();
})
```

--------------------------------

### Basic 3D Physics Simulation with Rapier.rs

Source: https://www.rapier.rs/docs/user_guides/rust/getting_started

This Rust code demonstrates a basic 3D physics simulation using the Rapier.rs library. It sets up a static ground plane and a dynamic ball with restitution, then runs the simulation for a fixed number of steps, printing the ball's altitude each step. Dependencies include the 'rapier3d' crate.

```rust
use rapier3d::prelude::*;
  
fn main() {
    let mut rigid_body_set = RigidBodySet::new();
    let mut collider_set = ColliderSet::new();

    /* Create the ground. */
    let collider = ColliderBuilder::cuboid(100.0, 0.1, 100.0).build();
    collider_set.insert(collider);

    /* Create the bounding ball. */
    let rigid_body = RigidBodyBuilder::dynamic()
        .translation(vector![0.0, 10.0, 0.0])
        .build();
    let collider = ColliderBuilder::ball(0.5).restitution(0.7).build();
    let ball_body_handle = rigid_body_set.insert(rigid_body);
    collider_set.insert_with_parent(collider, ball_body_handle, &mut rigid_body_set);

    /* Create other structures necessary for the simulation. */
    let gravity = vector![0.0, -9.81, 0.0];
    let integration_parameters = IntegrationParameters::default();
    let mut physics_pipeline = PhysicsPipeline::new();
    let mut island_manager = IslandManager::new();
    let mut broad_phase = DefaultBroadPhase::new();
    let mut narrow_phase = NarrowPhase::new();
    let mut impulse_joint_set = ImpulseJointSet::new();
    let mut multibody_joint_set = MultibodyJointSet::new();
    let mut ccd_solver = CCDSolver::new();
    let physics_hooks = ();
    let event_handler = ();

    /* Run the game loop, stepping the simulation once per frame. */
    for _ in 0..200 {
        physics_pipeline.step(
            &gravity,
            &integration_parameters,
            &mut island_manager,
            &mut broad_phase,
            &mut narrow_phase,
            &mut rigid_body_set,
            &mut collider_set,
            &mut impulse_joint_set,
            &mut multibody_joint_set,
            &mut ccd_solver,
            &physics_hooks,
            &event_handler,
        );

        let ball_body = &rigid_body_set[ball_body_handle];
        println!("Ball altitude: {}", ball_body.translation().y);
    }
}

```

--------------------------------

### Basic 2D Physics Simulation with Rapier.rs

Source: https://www.rapier.rs/docs/user_guides/rust/getting_started

This Rust code demonstrates a basic 2D physics simulation using the Rapier.rs library. It sets up a static ground and a dynamic ball with restitution, then runs the simulation for a fixed number of steps, printing the ball's altitude each step. Dependencies include the 'rapier2d' crate.

```rust
use rapier2d::prelude::*;
  
fn main() {
    let mut rigid_body_set = RigidBodySet::new();
    let mut collider_set = ColliderSet::new();

    /* Create the ground. */
    let collider = ColliderBuilder::cuboid(100.0, 0.1).build();
    collider_set.insert(collider);

    /* Create the bouncing ball. */
    let rigid_body = RigidBodyBuilder::dynamic()
        .translation(vector![0.0, 10.0])
        .build();
    let collider = ColliderBuilder::ball(0.5).restitution(0.7).build();
    let ball_body_handle = rigid_body_set.insert(rigid_body);
    collider_set.insert_with_parent(collider, ball_body_handle, &mut rigid_body_set);

    /* Create other structures necessary for the simulation. */
    let gravity = vector![0.0, -9.81];
    let integration_parameters = IntegrationParameters::default();
    let mut physics_pipeline = PhysicsPipeline::new();
    let mut island_manager = IslandManager::new();
    let mut broad_phase = DefaultBroadPhase::new();
    let mut narrow_phase = NarrowPhase::new();
    let mut impulse_joint_set = ImpulseJointSet::new();
    let mut multibody_joint_set = MultibodyJointSet::new();
    let mut ccd_solver = CCDSolver::new();
    let physics_hooks = ();
    let event_handler = ();

    /* Run the game loop, stepping the simulation once per frame. */
    for _ in 0..200 {
        physics_pipeline.step(
            &gravity,
            &integration_parameters,
            &mut island_manager,
            &mut broad_phase,
            &mut narrow_phase,
            &mut rigid_body_set,
            &mut collider_set,
            &mut impulse_joint_set,
            &mut multibody_joint_set,
            &mut ccd_solver,
            &physics_hooks,
            &event_handler,
        );

        let ball_body = &rigid_body_set[ball_body_handle];
        println!("Ball altitude: {}", ball_body.translation().y);
    }
}

```

--------------------------------

### Initialize Rapier 2D Physics World with Bundler

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Demonstrates asynchronous initialization of the Rapier 2D WebAssembly module. It sets up a basic physics world with gravity, a ground, and a dynamic rigid body, then runs a simple game loop to simulate physics.

```javascript
import('@dimforge/rapier2d').then(RAPIER => {
    // Use the RAPIER module here.
    let gravity = { x: 0.0, y: -9.81 };
    let world = new RAPIER.World(gravity);

    // Create the ground
    let groundColliderDesc = RAPIER.ColliderDesc.cuboid(10.0, 0.1);
    world.createCollider(groundColliderDesc);

    // Create a dynamic rigid-body.
    let rigidBodyDesc = RAPIER.RigidBodyDesc.dynamic()
        .setTranslation(0.0, 1.0);
    let rigidBody = world.createRigidBody(rigidBodyDesc);

    // Create a cuboid collider attached to the dynamic rigidBody.
    let colliderDesc = RAPIER.ColliderDesc.cuboid(0.5, 0.5);
    let collider = world.createCollider(colliderDesc, rigidBody);

    // Game loop. Replace by your own game loop system.
    let gameLoop = () => {
        // Step the simulation forward.    
        world.step();

        // Get and print the rigid-body's position.
        let position = rigidBody.translation();
        console.log("Rigid-body position: ", position.x, position.y);

        setTimeout(gameLoop, 16);
    };

    gameLoop();
})
```

--------------------------------

### Setup and Usage of KinematicCharacterController in Bevy Rapier (2D)

Source: https://www.rapier.rs/docs/user_guides/bevy_plugin/character_controller

Demonstrates the setup and usage of the KinematicCharacterController for 2D physics in Bevy Rapier. It includes functions for initializing the physics world, updating the controller's translation, and reading the results of the movement. This approach is convenient for character control.

```rust
fn setup_physics(mut commands: Commands) {
    commands
        .spawn(RigidBody::KinematicPositionBased)
        .insert(Collider::ball(0.5))
        .insert(KinematicCharacterController::default());
}

fn update_system(mut controllers: Query<&mut KinematicCharacterController>) {
    for mut controller in controllers.iter_mut() {
        controller.translation = Some(Vec2::new(1.0, -0.5));
    }
}

fn read_result_system(controllers: Query<(Entity, &KinematicCharacterControllerOutput)>) {
    for (entity, output) in controllers.iter() {
        println!(
            "Entity {:?} moved by {:?} and touches the ground: ?",
            entity, output.effective_translation, output.grounded
        );
    }
}

```

--------------------------------

### Initialize Rapier 3D without Bundler (UMD)

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Initializes the Rapier 3D physics engine using a compatibility UMD package, suitable for environments without bundlers. It includes both promise-based and async/await initialization methods.

```javascript
import RAPIER from 'https://cdn.skypack.dev/@dimforge/rapier3d-compat';

RAPIER.init().then(() => {
    // Run the simulation.
    _run_simulation(RAPIER);
});

// OR using the await syntax:
async function run_simulation() {
    await RAPIER.init();
    // Run the simulation.
    _run_simulation(RAPIER);
}

```

--------------------------------

### Constructing 3D Isometries with nalgebra

Source: https://www.rapier.rs/docs/user_guides/rust/introduction_to_nalgebra

Illustrates different ways to construct a 3D Isometry using nalgebra. Examples cover creating an isometry with translation, rotation (using axis-angle representation), or a combination of both. It also shows how to verify the rotation and translation components.

```rust
use nalgebra::{Isometry3, vector};
let iso = Isometry3::translation(1.0, 2.0, 3.0);
let iso = Isometry3::rotation(vector![0.1, 0.5, 0.7]); // The vector is the rotation in axis-angle format.
let iso = Isometry3::new(vector![1.0, 2.0, 3.0], vector![0.1, 0.5, 0.7]);
assert_eq!(iso.rotation.scaled_axis(), vector![0.1, 0.5, 0.7]);
assert_eq!(iso.translation.vector, vector![1.0, 2.0, 3.0]);

```

--------------------------------

### Initialize Rapier 2D without Bundler (UMD)

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Initializes the Rapier 2D physics engine using a compatibility UMD package, suitable for environments without bundlers. It includes both promise-based and async/await initialization methods.

```javascript
import RAPIER from 'https://cdn.skypack.dev/@dimforge/rapier2d-compat';

RAPIER.init().then(() => {
    // Run the simulation.
});

// OR using the await syntax:
async function run_simulation() {
    await RAPIER.init();
    // Run the simulation.
    _run_simulation(RAPIER);
}
run_simulation()
```

--------------------------------

### Example: Ray-Casting with Query Filters in Rapier.rs

Source: https://www.rapier.rs/docs/user_guides/rust/scene_queries

Demonstrates how to configure and use `QueryFilter` with a ray-casting query in Rapier.rs. This example shows excluding dynamic colliders, sensors, a specific rigid body, defining collision groups, and using a custom predicate function for advanced filtering.

```rust
let ray = Ray::new(point![1.0, 2.0], vector![0.0, 1.0]);
let max_toi = 4.0;
let solid = true;
let filter = QueryFilter::exclude_dynamic()
    .exclude_sensors()
    .exclude_rigid_body(player_handle)
    .groups(InteractionGroups::new(
        Group::GROUP_1 | Group::GROUP_2,
        Group::GROUP_1,
    ))
    .predicate(&|handle, collider| collider.user_data == 10);
let query_pipeline = broad_phase.as_query_pipeline(
    narrow_phase.query_dispatcher(),
    &rigid_body_set,
    &collider_set,
    filter,
);

if let Some((handle, toi)) = query_pipeline.cast_ray(&ray, max_toi, solid) {
    // Handle the hit.
}
```

--------------------------------

### Add Rapier3D Dependency to Cargo.toml

Source: https://www.rapier.rs/docs/user_guides/rust/getting_started

This snippet demonstrates adding the rapier3d crate to your Cargo.toml file, enabling the 'simd-stable' feature for SIMD optimizations. Remember to update '*' with the current latest version.

```toml
[package]
name    = "example-using-rapier"
version = "0.0.0"
authors = [ "You" ]

[dependencies]
# TODO: Replace the * by the latest version number.
rapier3d = { version = "*", features = [ "simd-stable" ] }

[[bin]]
name = "example"
path = "./example.rs"

```

--------------------------------

### Set Friction Properties During Collider Creation (Rust)

Source: https://www.rapier.rs/docs/user_guides/rust/colliders

Demonstrates how to set the friction coefficient and friction combine rule for a collider when it is initially built. This is useful for defining the physical properties of an object from the start.

```rust
/* Set the friction coefficient and friction combine rule  
when the collider is created. */  
let collider = ColliderBuilder::ball(0.5)  
    .friction(0.7)  
    .friction_combine_rule(CoefficientCombineRule::Min)  
    .build();  

```

--------------------------------

### Create and Insert 3D Collider with Customizations (Rapier3D)

Source: https://www.rapier.rs/docs/user_guides/bevy_plugin/colliders

Demonstrates how to create and insert a 3D collider with various customization components such as Sensor, Transform, Friction, Restitution, and ColliderMassProperties. This example is for illustrative purposes and uses random input values.

```rust
use bevy_rapier3d::prelude::*;

commands
    .spawn(Collider::cuboid(1.0, 2.0, 1.0))
    .insert(Sensor)
    .insert(Transform::from_xyz(2.0, 0.0, 0.0))
    .insert(Friction::coefficient(0.7))
    .insert(Restitution::coefficient(0.3))
    .insert(ColliderMassProperties::Density(2.0));
```

--------------------------------

### Converting between nalgebra and glam types

Source: https://www.rapier.rs/docs/user_guides/rust/introduction_to_nalgebra

Shows examples of converting between nalgebra types (like Vector2, Vector3, Point2, Isometry3) and glam types (like Vec2, Vec3, Quat). This requires enabling specific cargo features for nalgebra, such as `convert-glam013` or `convert-glam014`.

```rust
// Here are just a few examples.
use nalgebra::{vector, Point2, Isometry3};
use glam::{Quat, Vec2, Vec3};

let na_vector = vector![1.0, 2.0, 3.0];
let glam_vector: Vec3 = na_vector.into();

let glam_vector = Vec2::new(1.0, 2.0);
let na_point: Point2<f32> = glam_vector.into();

let na_isometry: Isometry3<f32> =
    (Vec3::new(0.1, 2.0, 0.0), Quat::from_rotation_x(0.4)).into();

```

--------------------------------

### 3D Ray-Casting with Rapier

Source: https://www.rapier.rs/docs/user_guides/rust/scene_queries

Illustrates 3D ray-casting using Rapier's `QueryPipeline`. This example covers finding the first collider hit, obtaining the intersection normal, and iterating through all colliders intersected by the ray. It utilizes parameters like `max_toi` to define the ray's effective length.

```rust
let ray = Ray::new(point![1.0, 2.0, 3.0], vector![0.0, 1.0, 0.0]);
let max_toi = 4.0;
let solid = true;
let filter = QueryFilter::default();

let query_pipeline = broad_phase.as_query_pipeline(
    narrow_phase.query_dispatcher(),
    rigid_body_set,
    collider_set,
    filter,
);

if let Some((handle, toi)) = query_pipeline.cast_ray(
    &ray, max_toi, solid
) {
    // The first collider hit has the handle `handle` and it hit after
    // the ray travelled a distance equal to `ray.dir * toi`.
    let hit_point = ray.point_at(toi); // Same as: `ray.origin + ray.dir * toi`
    println!("Collider {:?} hit at point {}", handle, hit_point);
}


if let Some((handle, intersection)) = query_pipeline.cast_ray_and_get_normal(
    &ray, max_toi, solid
) {
    // This is similar to `QueryPipeline::cast_ray` illustrated above except
    // that it also returns the normal of the collider shape at the hit point.
    let hit_point = ray.point_at(intersection.time_of_impact);
    let hit_normal = intersection.normal;
    println!("Collider {:?} hit at point {} with normal {}", handle, hit_point, hit_normal);
}

for (handle, _, intersection) in query_pipeline.intersect_ray(ray, max_toi, solid) {
    // Callback called on each collider hit by the ray.
    let hit_point = ray.point_at(intersection.time_of_impact);
    let hit_normal = intersection.normal;
    println!("Collider {:?} hit at point {} with normal {}", handle, hit_point, hit_normal);
}
```

--------------------------------

### Create 3D Cuboid Collider with Mass Properties

Source: https://www.rapier.rs/docs/user_guides/rust/colliders

Illustrates the creation of a 3D cuboid collider with various methods for setting mass properties. Similar to the 2D example, this includes density, mass, or explicit mass properties. The rigid body's properties are updated upon collider attachment.

```rust
let rigid_body = RigidBodyBuilder::dynamic().build();
let rigid_body_handle = rigid_body_set.insert(rigid_body);
// First option: by setting the density of the collider (or we could just leave
//               its default value 1.0).
let collider = ColliderBuilder::cuboid(1.0, 2.0, 3.0).density(2.0).build();
// Second option: by setting the mass of the collider.
let collider = ColliderBuilder::cuboid(1.0, 2.0, 3.0).mass(0.8).build();
// Third option: by setting the mass_properties explicitly.
let collider = ColliderBuilder::cuboid(1.0, 2.0, 3.0)
    .mass_properties(MassProperties::new(
        point![0.0, 1.0, 0.0],
        0.5,
        vector![0.3, 0.2, 0.1],
    ))
    .build();
// When the collider is attached, the rigid_body's mass and angular
// inertia is automatically updated to take the collider into account.
let collider_handle =
    collider_set.insert_with_parent(collider, rigid_body_handle, &mut rigid_body_set);
```

--------------------------------

### Apply Impulses to Dynamic Bodies in Rapier.js

Source: https://www.rapier.rs/docs/user_guides/javascript/character_controller

This example shows how to configure the character controller to automatically apply impulses to dynamic bodies it collides with. This is useful when the character controller's offset prevents direct physical reactions, allowing for manual force application.

```javascript
let characterController = world.createCharacterController(0.01);
// Enable the automatic application of impulses to the dynamic bodies
// hit by the character along its path.
characterController.setApplyImpulsesToDynamicBodies(true);
```

--------------------------------

### Render Debug Shapes with Pixi.js (JavaScript)

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

An example of rendering debug shape data obtained from Rapier.js using Pixi.js and Pixi Viewport. It iterates through the vertex and color arrays to draw lines on the Pixi stage. Requires Pixi.js and Pixi Viewport as dependencies.

```javascript
import * as PIXI from "pixi.js";
import { Viewport } from "pixi-viewport";

render(world: RAPIER.World) {
    const { vertices, colors } = world.debugRender();

    this.lines.clear();

    for (let i = 0; i < vertices.length / 4; i += 1) {
        let color = PIXI.utils.rgb2hex([
            colors[i * 8],
            colors[i * 8 + 1],
            colors[i * 8 + 2],
        ]);
        this.lines.lineStyle(1.0, color, colors[i * 8 + 3], 0.5, true);
        this.lines.moveTo(vertices[i * 4], -vertices[i * 4 + 1]);
        this.lines.lineTo(vertices[i * 4 + 2], -vertices[i * 4 + 3]);
    }

    this.renderer.render(this.scene);
}
```

--------------------------------

### Get Debug Render Data (JavaScript)

Source: https://www.rapier.rs/docs/user_guides/javascript/getting_started_js

Retrieves flat arrays of vertex and color data from the Rapier physics world for rendering debug shapes. The `vertices` array contains line drawing points, and the `colors` array contains RGBA values. Colors are not configurable and depend on body/collider type and kinematic state.

```javascript
const { vertices, colors } = world.debugRender();
```

--------------------------------

### Constructing 2D Isometries with nalgebra

Source: https://www.rapier.rs/docs/user_guides/rust/introduction_to_nalgebra

Demonstrates various methods for creating a 2D Isometry using the nalgebra library. This includes creating an isometry with only translation, only rotation, or both. It also shows how to access the rotation angle and translation components.

```rust
use nalgebra::{Isometry2, vector};
let iso = Isometry2::translation(1.0, 2.0);
let iso = Isometry2::rotation(0.5); // 0.5 is a rotation angle in radians.
let iso = Isometry2::new(vector![1.0, 2.0], 0.5);
assert_eq!(iso.rotation.angle(), 0.5);
assert_eq!(iso.translation.vector.x, 1.0);
assert_eq!(iso.translation.vector.y, 2.0);

```

--------------------------------

### Add Rapier2D Dependency to Cargo.toml

Source: https://www.rapier.rs/docs/user_guides/rust/getting_started

This snippet shows how to add the rapier2d crate to your project's Cargo.toml file. It includes the 'simd-stable' feature for SIMD optimizations. Replace '*' with the latest version number.

```toml
[package]
name    = "example-using-rapier"
version = "0.0.0"
authors = [ "You" ]

[dependencies]
# TODO: Replace the * by the latest version number.
rapier2d = { version = "*", features = [ "simd-stable" ] }

[[bin]]
name = "example"
path = "./example.rs"

```

--------------------------------

### Create and Access 2D Vectors using nalgebra

Source: https://www.rapier.rs/docs/user_guides/rust/introduction_to_nalgebra

Demonstrates multiple ways to create 2D vectors (Vector2) using nalgebra, including constructors, macros, and conversions from arrays. It also shows how to access vector components via fields (x, y) or indexing.

```rust
use nalgebra::{Vector2, vector};
let v = Vector2::new(1.0, 2.0); // Basic constructor.
let v = vector![1.0, 2.0];      // Macro.
let v = [1.0, 2.0].into();      // From<[T; 2]> conversion.

let v = vector![1.0, 2.0]; // 2D vector.
assert_eq!(v.x, 1.0);  assert_eq!(v.y, 2.0);
assert_eq!(v[0], 1.0); assert_eq!(v[1], 2.0);
```

--------------------------------

### Configure Prismatic Joint Motor Velocity (3D)

Source: https://www.rapier.rs/docs/user_guides/bevy_plugin/joints

Configures a 3D prismatic joint motor to move with a target velocity and damping. This example shows the setup for a 3D prismatic joint with capsule colliders and specific motor settings.

```rust
let joint = PrismaticJointBuilder::new(Vec3::X)  
    .local_anchor1(Vec3::new(0.0, 0.0, 1.0))  
    .local_anchor2(Vec3::new(0.0, 0.0, -3.0))  
    .motor_velocity(0.1, 0.05);  
commands  
    .spawn(RigidBody::Dynamic)  
    .insert(Collider::capsule_y(1f32, 0.5f32))  
    .insert(ImpulseJoint::new(parent_entity, joint));  
```

--------------------------------

### Create and Access 3D Vectors using nalgebra

Source: https://www.rapier.rs/docs/user_guides/rust/introduction_to_nalgebra

Illustrates how to create 3D vectors (Vector3) using nalgebra with various methods like constructors, macros, and array conversions. It also covers accessing vector components using fields (x, y, z) or indexing.

```rust
use nalgebra::{Vector3, vector};
let v = Vector3::new(1.0, 2.0, 3.0); // Basic constructor.
let v = vector![1.0, 2.0, 3.0];      // Macro.
let v = [1.0, 2.0, 3.0].into();      // From<[T; 3]> conversion.

let v = vector![1.0, 2.0, 3.0]; // 3D vector.
assert_eq!(v.x, 1.0);  assert_eq!(v.y, 2.0);  assert_eq!(v.z, 3.0);
assert_eq!(v[0], 1.0); assert_eq!(v[1], 2.0); assert_eq!(v[2], 3.0);
```

--------------------------------

### 2D Ball Bouncing Simulation with Bevy-Rapier

Source: https://www.rapier.rs/docs/user_guides/bevy_plugin/getting_started_bevy

This Rust code demonstrates a 2D physics simulation using Bevy and Rapier. It sets up a dynamic ball with restitution bouncing on a static cuboid ground. The example includes camera setup, physics plugin initialization, and a system to print the ball's altitude.

```rust
use bevy::prelude::*;
use bevy_rapier2d::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0))
        .add_plugins(RapierDebugRenderPlugin::default())
        .add_systems(Startup, setup_graphics)
        .add_systems(Startup, setup_physics)
        .add_systems(Update, print_ball_altitude)
        .run();
}

fn setup_graphics(mut commands: Commands) {
    // Add a camera so we can see the debug-render.
    commands.spawn(Camera2d::default());
}

fn setup_physics(mut commands: Commands) {
    /* Create the ground. */
    commands
        .spawn(Collider::cuboid(500.0, 50.0))
        .insert(Transform::from_xyz(0.0, -100.0, 0.0));

    /* Create the bouncing ball. */
    commands
        .spawn(RigidBody::Dynamic)
        .insert(Collider::ball(50.0))
        .insert(Restitution::coefficient(0.7))
        .insert(Transform::from_xyz(0.0, 400.0, 0.0));
}

fn print_ball_altitude(positions: Query<&Transform, With<RigidBody>>) {
    for transform in positions.iter() {
        println!("Ball altitude: {}", transform.translation.y);
    }
}
```

--------------------------------

### Create and Access 2D Points using nalgebra

Source: https://www.rapier.rs/docs/user_guides/rust/introduction_to_nalgebra

Shows how to create 2D points (Point2) in nalgebra using constructors, macros, and array conversions. It demonstrates accessing point coordinates via fields (x, y) or indexing, similar to vectors.

```rust
use nalgebra::{Point2, point};
let pt = Point2::new(1.0, 2.0); // Basic constructor.
let pt = point![1.0, 2.0];      // Macro.
let pt = [1.0, 2.0].into();     // From<[T; 2]> conversion.
  
assert_eq!(pt.x, 1.0);  assert_eq!(pt.y, 2.0);
assert_eq!(pt[0], 1.0); assert_eq!(pt[1], 2.0);
```

--------------------------------

### Set Damping Coefficients After RigidBody Creation (Rust)

Source: https://www.rapier.rs/docs/user_guides/rust/rigid_bodies

Demonstrates how to set and verify linear and angular damping coefficients for an existing rigid-body. This allows runtime adjustment of how quickly the body's velocities decay.

```Rust
/* Set the damping coefficients after the rigid-body creation. */  
let rigid_body = rigid_body_set.get_mut(rigid_body_handle).unwrap();  
rigid_body.set_linear_damping(0.5);  
rigid_body.set_angular_damping(1.0);  
assert_eq!(rigid_body.linear_damping(), 0.5);  
assert_eq!(rigid_body.angular_damping(), 1.0);  
```

--------------------------------

### Create and Insert Colliders in Rapier.rs (3D)

Source: https://www.rapier.rs/docs/user_guides/rust/colliders

Demonstrates the creation of various 3D collider shapes (ball, cuboid, capsule, trimesh, heightfield) using `ColliderBuilder`. It also shows how to customize collider properties such as translation, rotation, density, and friction, and how to insert them into a `ColliderSet`, either standalone or attached to a rigid body.

```rust
use rapier3d::prelude::*;
use std::f32::consts::PI;

// The set that will contain our colliders.
let mut collider_set = ColliderSet::new();

// Builder for a ball-shaped collider.
let _ = ColliderBuilder::ball(0.5);
// Builder for a cuboid-shaped collider.
let _ = ColliderBuilder::cuboid(0.5, 0.2, 0.1);
// Builder for a capsule-shaped collider. The capsule principal axis is the `x` coordinate axis.
let _ = ColliderBuilder::capsule_x(0.5, 0.2);
// Builder for a capsule-shaped collider. The capsule principal axis is the `y` coordinate axis.
let _ = ColliderBuilder::capsule_y(0.5, 0.2);
// Builder for a capsule-shaped collider. The capsule principal axis is the `z` coordinate axis.
let _ = ColliderBuilder::capsule_z(0.5, 0.2);
// Builder for a triangle-mesh-shaped collider.
let _ = ColliderBuilder::trimesh(vertices, indices);
// Builder for a heightfield-shaped collider.
let _ = ColliderBuilder::heightfield(heights, scale);
// Builder for a collider with the given shape.
let collider = ColliderBuilder::new(SharedShape::ball(0.5))
    // The collider translation wrt. the body it is attached to.
    // Default: the zero vector.
    .translation(vector![1.0, 2.0, 3.0])
    // The collider rotation wrt. the body it is attached to.
    // Default: the identity rotation.
    .rotation(vector![0.0, PI, 0.0])
    // The collider position wrt. the body it is attached to.
    // Default: the identity isometry.
    .position(Isometry::new(vector![1.0, 2.0, 3.0], vector![0.0, PI, 0.0]))
    // The collider density. If non-zero the collider's mass and angular inertia will be added
    // to the inertial properties of the body it is attached to.
    // Default: 1.0
    .density(1.3)
    // The friction coefficient of this collider.
    // Default: ColliderBuilder::default_friction() == 0.5
    .friction(0.8)
    // Whether this collider is a sensor.
    // Default: false
    .sensor(true)
    // All done, actually build the collider.
    .build();

// Insert the collider into the set, without attaching to a rigid-body.
let handle = collider_set.insert(collider.clone());

```

--------------------------------

### Create and Configure Rigid Body in Rapier.js (3D)

Source: https://www.rapier.rs/docs/user_guides/javascript/rigid_bodies

Illustrates the process of creating and configuring rigid bodies in a 3D Rapier.js simulation. This includes defining different body types and customizing properties such as translation, quaternion rotation, linear/angular velocities, gravity scale, sleep status, and CCD using `RigidBodyDesc` before creating the body in the world.

```javascript
let world = new RAPIER.World({ x: 0.0, y: -9.81, z: 0.0 });

let example1 = RAPIER.RigidBodyDesc.fixed();
let example2 = RAPIER.RigidBodyDesc.dynamic();
let example3 = RAPIER.RigidBodyDesc.kinematicVelocityBased();
let example4 = RAPIER.RigidBodyDesc.kinematicPositionBased();

let rigidBodyDesc = new RAPIER.RigidBodyDesc(RAPIER.RigidBodyType.Dynamic)
    .setTranslation(0.0, 5.0, 1.0)
    .setRotation({ w: 1.0, x: 0.0, y: 0.0, z: 0.0 })
    .setLinvel(1.0, 3.0, 4.0)
    .setAngvel({ x: 3.0, y: 0.0, z: 1.0 })
    .setGravityScale(0.5)
    .setCanSleep(true)
    .setCcdEnabled(false);

let rigidBody = world.createRigidBody(rigidBodyDesc);
let rigidBodyHandle = rigidBody.handle;
```

--------------------------------

### Active Events

Source: https://www.rapier.rs/docs/user_guides/rust/colliders

Enable or disable the generation of collision events for a collider. At least one collider in a pair must have collision events activated to receive notifications when they start or stop touching.

```APIDOC
## Active Events

### Description
Enable or disable the generation of collision events for a collider. At least one collider in a pair must have collision events activated to receive notifications when they start or stop touching.

### Method
- `active_events(ActiveEvents)`: Sets the active events during collider creation.
- `set_active_events(ActiveEvents)`: Modifies the active events after collider creation.

### Parameters
#### Request Body (Implicit via Builder/Method)
- **ActiveEvents**: An enum that can be used to specify desired event behaviors. `ActiveEvents::COLLISION_EVENTS` enables collision start/stop notifications.

### Request Example (Creation)
```rust
let collider = ColliderBuilder::ball(0.5)
    .active_events(ActiveEvents::COLLISION_EVENTS)
    .build();
```

### Request Example (Update)
```rust
let collider = collider_set.get_mut(collider_handle).unwrap();
collider.set_active_events(ActiveEvents::COLLISION_EVENTS);
```

### Response
#### Success Response (Implicit)
- The collider's active events are updated.

#### Response Example (Assertion)
```rust
assert!(collider.active_events().contains(ActiveEvents::COLLISION_EVENTS));
```
```

--------------------------------

### Create and Insert Colliders in Rapier.rs (2D)

Source: https://www.rapier.rs/docs/user_guides/rust/colliders

Demonstrates the creation of various 2D collider shapes (ball, cuboid, capsule, trimesh, heightfield) using `ColliderBuilder`. It also shows how to customize collider properties such as translation, rotation, density, and friction, and how to insert them into a `ColliderSet`, either standalone or attached to a rigid body.

```rust
use rapier2d::prelude::*;
use std::f32::consts::PI;

// The set that will contain our colliders.
let mut collider_set = ColliderSet::new();

// Builder for a ball-shaped collider.
let _ = ColliderBuilder::ball(0.5);
// Builder for a cuboid-shaped collider.
let _ = ColliderBuilder::cuboid(0.5, 0.2);
// Builder for a capsule-shaped collider. The capsule principal axis is the `x` coordinate axis.
let _ = ColliderBuilder::capsule_x(0.5, 0.2);
// Builder for a capsule-shaped collider. The capsule principal axis is the `y` coordinate axis.
let _ = ColliderBuilder::capsule_y(0.5, 0.2);
// Builder for a triangle-mesh-shaped collider.
let _ = ColliderBuilder::trimesh(vertices, indices);
// Builder for a heightfield-shaped collider.
let _ = ColliderBuilder::heightfield(heights, scale);
// Builder for a collider with the given shape.
let collider = ColliderBuilder::new(SharedShape::ball(0.5))
    // The collider translation wrt. the body it is attached to.
    // Default: the zero vector.
    .translation(vector![1.0, 2.0])
    // The collider rotation wrt. the body it is attached to.
    // Default: the identity rotation.
    .rotation(PI)
    // The collider position wrt. the body it is attached to.
    // Default: the identity isometry.
    .position(Isometry::new(vector![1.0, 2.0], PI))
    // The collider density. If non-zero the collider's mass and angular inertia will be added
    // to the inertial properties of the body it is attached to.
    // Default: 1.0
    .density(1.3)
    // The friction coefficient of this collider.
    // Default: ColliderBuilder::default_friction() == 0.5
    .friction(0.8)
    // Whether this collider is a sensor.
    // Default: false
    .sensor(true)
    // All done, actually build the collider.
    .build();

// Insert the collider into the set, without attaching it to a rigid-body.
let collider_handle = collider_set.insert(collider.clone());

let mut rigid_body_set = RigidBodySet::new();
let rigid_body_handle = rigid_body_set.insert(RigidBodyBuilder::dynamic().build());
// Or insert the collider into the set and attach it to a rigid-body.
let handle = collider_set.insert_with_parent(collider, rigid_body_handle, &mut rigid_body_set);

```