Profiling support (#743)

src/control/character_controller.rs

@@ -211,6 +211,7 @@ impl KinematicCharacterController {
     }
 
     /// Computes the possible movement for a shape.
+    #[profiling::function]
     pub fn move_shape(
         &self,
         dt: Real,
@@ -430,6 +431,7 @@ impl KinematicCharacterController {
         self.offset.eval(up_extends) + 0.05
     }
 
+    #[profiling::function]
     fn detect_grounded_status_and_apply_friction(
         &self,
         dt: Real,
@@ -657,6 +659,7 @@ impl KinematicCharacterController {
         Vector2::new(side_extent, up_extent)
     }
 
+    #[profiling::function]
     fn handle_stairs(
         &self,
         bodies: &RigidBodySet,
@@ -817,6 +820,7 @@ impl KinematicCharacterController {
     /// impulses to the rigid-bodies surrounding the character shape at the time of the collisions.
     /// Note that the impulse calculation is only approximate as it is not based on a global
     /// constraints resolution scheme.
+    #[profiling::function]
     pub fn solve_character_collision_impulses<'a>(
         &self,
         dt: Real,
@@ -846,6 +850,7 @@ impl KinematicCharacterController {
     /// impulses to the rigid-bodies surrounding the character shape at the time of the collision.
     /// Note that the impulse calculation is only approximate as it is not based on a global
     /// constraints resolution scheme.
+    #[profiling::function]
     fn solve_single_character_collision_impulse(
         &self,
         dt: Real,

src/control/ray_cast_vehicle_controller.rs

@@ -321,6 +321,7 @@ impl DynamicRayCastVehicleController {
         wheel.wheel_axle_ws = chassis_transform * wheel.axle_cs;
     }
 
+    #[profiling::function]
     fn ray_cast(
         &mut self,
         bodies: &RigidBodySet,
@@ -403,6 +404,7 @@ impl DynamicRayCastVehicleController {
     }
 
     /// Updates the vehicle’s velocity based on its suspension, engine force, and brake.
+    #[profiling::function]
     pub fn update_vehicle(
         &mut self,
         dt: Real,
@@ -531,6 +533,7 @@ impl DynamicRayCastVehicleController {
         }
     }
 
+    #[profiling::function]
     fn update_friction(&mut self, bodies: &mut RigidBodySet, colliders: &ColliderSet, dt: Real) {
         let num_wheels = self.wheels.len();
 

src/dynamics/ccd/ccd_solver.rs

@@ -108,6 +108,7 @@ impl CCDSolver {
     }
 
     /// Find the first time a CCD-enabled body has a non-sensor collider hitting another non-sensor collider.
+    #[profiling::function]
     pub fn find_first_impact(
         &mut self,
         dt: Real,
@@ -225,6 +226,7 @@ impl CCDSolver {
     }
 
     /// Outputs the set of bodies as well as their first time-of-impact event.
+    #[profiling::function]
     pub fn predict_impacts_at_next_positions(
         &mut self,
         dt: Real,

src/dynamics/ccd/toi_entry.rs

@@ -34,6 +34,7 @@ impl TOIEntry {
         }
     }
 
+    #[profiling::function]
     pub fn try_from_colliders<QD: ?Sized + QueryDispatcher>(
         query_dispatcher: &QD,
         ch1: ColliderHandle,

src/dynamics/joint/impulse_joint/impulse_joint_set.rs

@@ -244,6 +244,7 @@ impl ImpulseJointSet {
     ///
     /// If `wake_up` is set to `true`, then the bodies attached to this joint will be
     /// automatically woken up during the next timestep.
+    #[profiling::function]
     pub fn insert(
         &mut self,
         body1: RigidBodyHandle,
@@ -329,6 +330,7 @@ impl ImpulseJointSet {
     ///
     /// If `wake_up` is set to `true`, then the bodies attached to this joint will be
     /// automatically woken up.
+    #[profiling::function]
     pub fn remove(&mut self, handle: ImpulseJointHandle, wake_up: bool) -> Option<ImpulseJoint> {
         let id = self.joint_ids.remove(handle.0)?;
         let endpoints = self.joint_graph.graph.edge_endpoints(id)?;
@@ -356,6 +358,7 @@ impl ImpulseJointSet {
     /// The provided rigid-body handle is not required to identify a rigid-body that
     /// is still contained by the `bodies` component set.
     /// Returns the (now invalid) handles of the removed impulse_joints.
+    #[profiling::function]
     pub fn remove_joints_attached_to_rigid_body(
         &mut self,
         handle: RigidBodyHandle,

src/dynamics/joint/multibody_joint/multibody.rs

@@ -489,6 +489,7 @@ impl Multibody {
     }
 
     /// Computes the constant terms of the dynamics.
+    #[profiling::function]
     pub(crate) fn update_dynamics(&mut self, dt: Real, bodies: &mut RigidBodySet) {
         /*
          * Compute velocities.
@@ -1094,6 +1095,7 @@ impl Multibody {
     /// is the sum of the current position of `self` and this `displacement`.
     // TODO: this shares a lot of code with `forward_kinematics` and `update_body_jacobians`, except
     //       that we are only traversing a single kinematic chain. Could this be refactored?
+    #[profiling::function]
     pub fn forward_kinematics_single_branch(
         &self,
         bodies: &RigidBodySet,

src/dynamics/joint/multibody_joint/multibody_ik.rs

@@ -64,6 +64,7 @@ impl Multibody {
     /// desired transform.
     ///
     /// The displacement calculated by this function is added to the `displacement` vector.
+    #[profiling::function]
     pub fn inverse_kinematics_delta_with_jacobian(
         jacobian: &Jacobian<Real>,
         desired_movement: &SpacialVector<Real>,
@@ -88,6 +89,7 @@ impl Multibody {
     /// can be moved through the inverse-kinematics process. Any joint for which `joint_can_move`
     /// returns `false` will have its corresponding displacement constrained to 0.
     /// Set the closure to `|_| true` if all the joints are free to move.
+    #[profiling::function]
     pub fn inverse_kinematics(
         &self,
         bodies: &RigidBodySet,

src/dynamics/joint/multibody_joint/multibody_joint.rs

@@ -86,6 +86,7 @@ impl MultibodyJoint {
     }
 
     /// Integrate the position of this multibody_joint.
+    #[profiling::function]
     pub fn integrate(&mut self, dt: Real, vels: &[Real]) {
         let locked_bits = self.data.locked_axes.bits();
         let mut curr_free_dof = 0;

src/dynamics/joint/multibody_joint/multibody_joint_set.rs

@@ -153,6 +153,7 @@ impl MultibodyJointSet {
     }
 
     /// Inserts a new multibody_joint into this set.
+    #[profiling::function]
     fn do_insert(
         &mut self,
         body1: RigidBodyHandle,
@@ -213,6 +214,7 @@ impl MultibodyJointSet {
     }
 
     /// Removes a multibody_joint from this set.
+    #[profiling::function]
     pub fn remove(&mut self, handle: MultibodyJointHandle, wake_up: bool) {
         if let Some(removed) = self.rb2mb.get(handle.0).copied() {
             let multibody = self.multibodies.remove(removed.multibody.0).unwrap();
@@ -259,6 +261,7 @@ impl MultibodyJointSet {
     }
 
     /// Removes all the multibody_joints from the multibody the given rigid-body is part of.
+    #[profiling::function]
     pub fn remove_multibody_articulations(&mut self, handle: RigidBodyHandle, wake_up: bool) {
         if let Some(removed) = self.rb2mb.get(handle.0).copied() {
             // Remove the multibody.
@@ -281,6 +284,7 @@ impl MultibodyJointSet {
     }
 
     /// Removes all the multibody joints attached to a rigid-body.
+    #[profiling::function]
     pub fn remove_joints_attached_to_rigid_body(&mut self, rb_to_remove: RigidBodyHandle) {
         // TODO: optimize this.
         if let Some(link_to_remove) = self.rb2mb.get(rb_to_remove.0).copied() {
@@ -412,6 +416,7 @@ impl MultibodyJointSet {
     }
 
     /// Iterates through all the joints attached to the given rigid-body.
+    #[profiling::function]
     pub fn attached_joints(
         &self,
         rb: RigidBodyHandle,
@@ -441,6 +446,7 @@ impl MultibodyJointSet {
 
     /// Iterate through the handles of all the rigid-bodies attached to this rigid-body
     /// by an enabled multibody_joint.
+    #[profiling::function]
     pub fn bodies_attached_with_enabled_joint(
         &self,
         body: RigidBodyHandle,

src/dynamics/rigid_body.rs

@@ -1016,6 +1016,7 @@ impl RigidBody {
     /// Applies an impulse at the center-of-mass of this rigid-body.
     /// The impulse is applied right away, changing the linear velocity.
     /// This does nothing on non-dynamic bodies.
+    #[profiling::function]
     pub fn apply_impulse(&mut self, impulse: Vector<Real>, wake_up: bool) {
         if !impulse.is_zero() && self.body_type == RigidBodyType::Dynamic {
             self.vels.linvel += impulse.component_mul(&self.mprops.effective_inv_mass);
@@ -1030,6 +1031,7 @@ impl RigidBody {
     /// The impulse is applied right away, changing the angular velocity.
     /// This does nothing on non-dynamic bodies.
     #[cfg(feature = "dim2")]
+    #[profiling::function]
     pub fn apply_torque_impulse(&mut self, torque_impulse: Real, wake_up: bool) {
         if !torque_impulse.is_zero() && self.body_type == RigidBodyType::Dynamic {
             self.vels.angvel += self.mprops.effective_world_inv_inertia_sqrt
@@ -1045,6 +1047,7 @@ impl RigidBody {
     /// The impulse is applied right away, changing the angular velocity.
     /// This does nothing on non-dynamic bodies.
     #[cfg(feature = "dim3")]
+    #[profiling::function]
     pub fn apply_torque_impulse(&mut self, torque_impulse: Vector<Real>, wake_up: bool) {
         if !torque_impulse.is_zero() && self.body_type == RigidBodyType::Dynamic {
             self.vels.angvel += self.mprops.effective_world_inv_inertia_sqrt

src/dynamics/rigid_body_components.rs

@@ -624,6 +624,7 @@ impl RigidBodyVelocity {
 
     /// The kinetic energy of this rigid-body.
     #[must_use]
+    #[profiling::function]
     pub fn kinetic_energy(&self, rb_mprops: &RigidBodyMassProps) -> Real {
         let mut energy = (rb_mprops.mass() * self.linvel.norm_squared()) / 2.0;
 

src/dynamics/rigid_body_set.rs

@@ -84,6 +84,7 @@ impl RigidBodySet {
     }
 
     /// Removes a rigid-body, and all its attached colliders and impulse_joints, from these sets.
+    #[profiling::function]
     pub fn remove(
         &mut self,
         handle: RigidBodyHandle,

src/dynamics/solver/contact_constraint/contact_constraints_set.rs

@@ -454,6 +454,7 @@ impl ContactConstraintsSet {
         }
     }
 
+    #[profiling::function]
     pub fn solve_restitution(
         &mut self,
         solver_vels: &mut [SolverVel<Real>],
@@ -465,6 +466,7 @@ impl ContactConstraintsSet {
         }
     }
 
+    #[profiling::function]
     pub fn solve_restitution_wo_bias(
         &mut self,
         solver_vels: &mut [SolverVel<Real>],
@@ -477,6 +479,7 @@ impl ContactConstraintsSet {
         }
     }
 
+    #[profiling::function]
     pub fn solve_friction(
         &mut self,
         solver_vels: &mut [SolverVel<Real>],
@@ -495,6 +498,7 @@ impl ContactConstraintsSet {
         }
     }
 
+    #[profiling::function]
     pub fn update(
         &mut self,
         params: &IntegrationParameters,

src/dynamics/solver/contact_constraint/generic_one_body_constraint.rs

@@ -272,6 +272,7 @@ impl GenericOneBodyConstraint {
         );
     }
 
+    #[profiling::function]
     pub fn solve(
         &mut self,
         jacobians: &DVector<Real>,

src/dynamics/solver/interaction_groups.rs

@@ -218,6 +218,7 @@ impl InteractionGroups {
     }
 
     #[cfg(feature = "simd-is-enabled")]
+    #[profiling::function]
     pub fn group_joints(
         &mut self,
         island_id: usize,

src/dynamics/solver/island_solver.rs

@@ -28,6 +28,7 @@ impl IslandSolver {
         }
     }
 
+    #[profiling::function]
     pub fn init_and_solve(
         &mut self,
         island_id: usize,

src/dynamics/solver/joint_constraint/joint_constraints_set.rs

@@ -361,6 +361,7 @@ impl JointConstraintsSet {
         }
     }
 
+    #[profiling::function]
     pub fn solve(
         &mut self,
         solver_vels: &mut [SolverVel<Real>],
@@ -391,6 +392,7 @@ impl JointConstraintsSet {
         }
     }
 
+    #[profiling::function]
     pub fn update(
         &mut self,
         params: &IntegrationParameters,

src/dynamics/solver/joint_constraint/joint_velocity_constraint.rs

@@ -110,6 +110,7 @@ pub struct JointTwoBodyConstraint<N: SimdRealCopy, const LANES: usize> {
 }
 
 impl<N: SimdRealCopy, const LANES: usize> JointTwoBodyConstraint<N, LANES> {
+    #[profiling::function]
     pub fn solve_generic(
         &mut self,
         solver_vel1: &mut SolverVel<N>,

src/dynamics/solver/parallel_island_solver.rs

@@ -160,6 +160,7 @@ impl ParallelIslandSolver {
         }
     }
 
+    #[profiling::function]
     pub fn init_and_solve<'s>(
         &'s mut self,
         scope: &Scope<'s>,

src/dynamics/solver/velocity_solver.rs

@@ -149,6 +149,7 @@ impl VelocitySolver {
         }
     }
 
+    #[profiling::function]
     pub fn solve_constraints(
         &mut self,
         params: &IntegrationParameters,
@@ -221,6 +222,7 @@ impl VelocitySolver {
         }
     }
 
+    #[profiling::function]
     pub fn integrate_positions(
         &mut self,
         params: &IntegrationParameters,

src/geometry/broad_phase_multi_sap/broad_phase_multi_sap.rs

@@ -254,6 +254,7 @@ impl BroadPhaseMultiSap {
     /// This will:
     /// - Remove all the subregion proxies from the larger layer.
     /// - Pre-insert all the smaller layer's region proxies into this layer.
+    #[profiling::function]
     fn finalize_layer_insertion(&mut self, layer_id: u8) {
         // Remove all the region endpoints from the larger layer.
         // They will be automatically replaced by the new layer's regions.
@@ -289,6 +290,7 @@ impl BroadPhaseMultiSap {
     ///    the `update` function.
     /// 4. All the regions from the smaller layer are added to that new
     ///    layer.
+    #[profiling::function]
     fn ensure_layer_exists(&mut self, new_depth: i8) -> u8 {
         // Special case: we don't have any layers yet.
         if self.layers.is_empty() {
@@ -473,6 +475,7 @@ impl BroadPhaseMultiSap {
     /// added to its larger layer so we can detect when an object
     /// in a larger layer may start interacting with objects in a smaller
     /// layer.
+    #[profiling::function]
     fn propagate_created_regions(&mut self) {
         let mut curr_layer = Some(self.smallest_layer);
 
@@ -502,6 +505,7 @@ impl BroadPhaseMultiSap {
         }
     }
 
+    #[profiling::function]
     fn update_layers_and_find_pairs(&mut self, out_events: &mut Vec<BroadPhasePairEvent>) {
         if self.layers.is_empty() {
             return;
@@ -579,6 +583,7 @@ impl BroadPhaseMultiSap {
 
 impl BroadPhase for BroadPhaseMultiSap {
     /// Updates the broad-phase, taking into account the new collider positions.
+    #[profiling::function]
     fn update(
         &mut self,
         dt: Real,

src/geometry/broad_phase_multi_sap/sap_axis.rs

@@ -36,6 +36,7 @@ impl SAPAxis {
         self.endpoints.push(SAPEndpoint::end_sentinel());
     }
 
+    #[profiling::function]
     pub fn batch_insert(
         &mut self,
         dim: usize,

src/geometry/broad_phase_multi_sap/sap_layer.rs

@@ -49,6 +49,7 @@ impl SAPLayer {
     /// Deletes from all the regions of this layer, all the endpoints corresponding
     /// to subregions. Clears the arrays of subregions indices from all the regions of
     /// this layer.
+    #[profiling::function]
     pub fn unregister_all_subregions(&mut self, proxies: &mut SAPProxies) {
         for region_id in self.regions.values() {
             // Extract the region to make the borrow-checker happy.
@@ -108,6 +109,7 @@ impl SAPLayer {
     /// that subregion center. Because the hierarchical grid cells have aligned boundaries
     /// at each depth, we have the guarantee that a given subregion will only be part of
     /// one region on its parent "larger" layer.
+    #[profiling::function]
     fn register_subregion(
         &mut self,
         proxy_id: BroadPhaseProxyIndex,
@@ -145,6 +147,7 @@ impl SAPLayer {
         }
     }
 
+    #[profiling::function]
     fn unregister_subregion(
         &mut self,
         proxy_id: BroadPhaseProxyIndex,
@@ -273,6 +276,7 @@ impl SAPLayer {
         }
     }
 
+    #[profiling::function]
     pub fn predelete_proxy(&mut self, proxies: &mut SAPProxies, proxy_index: BroadPhaseProxyIndex) {
         // Discretize the Aabb to find the regions that need to be invalidated.
         let proxy_aabb = &mut proxies[proxy_index].aabb;

src/geometry/broad_phase_multi_sap/sap_region.rs

@@ -214,6 +214,7 @@ impl SAPRegion {
         }
     }
 
+    #[profiling::function]
     pub fn update(
         &mut self,
         proxies: &SAPProxies,

src/geometry/contact_pair.rs

@@ -186,6 +186,7 @@ impl ContactPair {
     ///
     /// Returns a reference to the contact, as well as the contact manifold
     /// it is part of.
+    #[profiling::function]
     pub fn find_deepest_contact(&self) -> Option<(&ContactManifold, &Contact)> {
         let mut deepest = None;
 

src/geometry/interaction_graph.rs

@@ -96,6 +96,7 @@ impl<N: Copy, E> InteractionGraph<N, E> {
     }
 
     /// The interaction between the two collision objects identified by their graph index.
+    #[profiling::function]
     pub fn interaction_pair(
         &self,
         id1: ColliderGraphIndex,
@@ -111,6 +112,7 @@ impl<N: Copy, E> InteractionGraph<N, E> {
     }
 
     /// The interaction between the two collision objects identified by their graph index.
+    #[profiling::function]
     pub fn interaction_pair_mut(
         &mut self,
         id1: ColliderGraphIndex,

src/geometry/mesh_converter.rs

@@ -53,6 +53,7 @@ pub enum MeshConverter {
 impl MeshConverter {
     /// Applies the conversion rule described by this [`MeshConverter`] to build a shape from
     /// the given vertex and index buffers.
+    #[profiling::function]
     pub fn convert(
         &self,
         vertices: Vec<Point<Real>>,

src/geometry/narrow_phase.rs

@@ -268,6 +268,7 @@ impl NarrowPhase {
     // }
 
     /// Maintain the narrow-phase internal state by taking collider removal into account.
+    #[profiling::function]
     pub fn handle_user_changes(
         &mut self,
         mut islands: Option<&mut IslandManager>,
@@ -321,6 +322,7 @@ impl NarrowPhase {
         );
     }
 
+    #[profiling::function]
     pub(crate) fn remove_collider(
         &mut self,
         intersection_graph_id: ColliderGraphIndex,
@@ -412,6 +414,7 @@ impl NarrowPhase {
         }
     }
 
+    #[profiling::function]
     pub(crate) fn handle_user_changes_on_colliders(
         &mut self,
         mut islands: Option<&mut IslandManager>,
@@ -513,6 +516,7 @@ impl NarrowPhase {
         }
     }
 
+    #[profiling::function]
     fn remove_pair(
         &mut self,
         islands: Option<&mut IslandManager>,
@@ -584,6 +588,7 @@ impl NarrowPhase {
         }
     }
 
+    #[profiling::function]
     fn add_pair(&mut self, colliders: &ColliderSet, pair: &ColliderPair) {
         if let (Some(co1), Some(co2)) =
             (colliders.get(pair.collider1), colliders.get(pair.collider2))
@@ -687,6 +692,7 @@ impl NarrowPhase {
         }
     }
 
+    #[profiling::function]
     pub(crate) fn compute_intersections(
         &mut self,
         bodies: &RigidBodySet,
@@ -785,6 +791,7 @@ impl NarrowPhase {
         });
     }
 
+    #[profiling::function]
     pub(crate) fn compute_contacts(
         &mut self,
         prediction_distance: Real,

src/pipeline/debug_render_pipeline/debug_render_pipeline.rs

@@ -85,6 +85,7 @@ impl DebugRenderPipeline {
     }
 
     /// Render the scene.
+    #[profiling::function]
     pub fn render(
         &mut self,
         backend: &mut impl DebugRenderBackend,
@@ -101,6 +102,7 @@ impl DebugRenderPipeline {
     }
 
     /// Render contact.
+    #[profiling::function]
     pub fn render_contacts(
         &mut self,
         backend: &mut impl DebugRenderBackend,
@@ -167,6 +169,7 @@ impl DebugRenderPipeline {
     }
 
     /// Render only the joints from the scene.
+    #[profiling::function]
     pub fn render_joints(
         &mut self,
         backend: &mut impl DebugRenderBackend,
@@ -249,6 +252,7 @@ impl DebugRenderPipeline {
     }
 
     /// Render only the rigid-bodies from the scene.
+    #[profiling::function]
     pub fn render_rigid_bodies(
         &mut self,
         backend: &mut impl DebugRenderBackend,
@@ -288,6 +292,7 @@ impl DebugRenderPipeline {
     }
 
     /// Render only the colliders from the scene.
+    #[profiling::function]
     pub fn render_colliders(
         &mut self,
         backend: &mut impl DebugRenderBackend,
@@ -351,6 +356,7 @@ impl DebugRenderPipeline {
     }
 
     #[cfg(feature = "dim2")]
+    #[profiling::function]
     fn render_shape(
         &mut self,
         object: DebugRenderObject,
@@ -458,6 +464,7 @@ impl DebugRenderPipeline {
     }
 
     #[cfg(feature = "dim3")]
+    #[profiling::function]
     fn render_shape(
         &mut self,
         object: DebugRenderObject,

src/pipeline/query_pipeline/mod.rs

@@ -312,6 +312,7 @@ impl QueryPipeline {
 
     /// Update the query pipeline incrementally, avoiding a complete rebuild of its
     /// internal data-structure.
+    #[profiling::function]
     pub fn update_incremental(
         &mut self,
         colliders: &ColliderSet,
@@ -353,6 +354,7 @@ impl QueryPipeline {
     /// volume generator.
     ///
     /// See [`generators`] for available generators.
+    #[profiling::function]
     pub fn update_with_generator(&mut self, mode: impl QbvhDataGenerator<ColliderHandle>) {
         self.qbvh.clear_and_rebuild(mode, self.dilation_factor);
     }
@@ -368,6 +370,7 @@ impl QueryPipeline {
     ///            it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
     ///            even if its starts inside of it.
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn cast_ray(
         &self,
         bodies: &RigidBodySet,
@@ -395,6 +398,7 @@ impl QueryPipeline {
     ///            it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
     ///            even if its starts inside of it.
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn cast_ray_and_get_normal(
         &self,
         bodies: &RigidBodySet,
@@ -429,6 +433,7 @@ impl QueryPipeline {
     /// * `callback`: function executed on each collider for which a ray intersection has been found.
     ///               There is no guarantees on the order the results will be yielded. If this callback returns `false`,
     ///               this method will exit early, ignore any further raycast.
+    #[profiling::function]
     pub fn intersections_with_ray<'a>(
         &self,
         bodies: &'a RigidBodySet,
@@ -465,6 +470,7 @@ impl QueryPipeline {
     /// * `shape_pos` - The position of the shape used for the intersection test.
     /// * `shape` - The shape used for the intersection test.
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn intersection_with_shape(
         &self,
         bodies: &RigidBodySet,
@@ -501,6 +507,7 @@ impl QueryPipeline {
     ///   (if the point is located inside of an hollow shape, it is projected on the shape's
     ///   boundary).
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn project_point(
         &self,
         bodies: &RigidBodySet,
@@ -526,6 +533,7 @@ impl QueryPipeline {
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
     /// * `callback` - A function called with each collider with a shape
     ///                containing the `point`.
+    #[profiling::function]
     pub fn intersections_with_point(
         &self,
         bodies: &RigidBodySet,
@@ -562,6 +570,7 @@ impl QueryPipeline {
     ///   (if the point is located inside of an hollow shape, it is projected on the shape's
     ///   boundary).
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn project_point_and_get_feature(
         &self,
         bodies: &RigidBodySet,
@@ -578,6 +587,7 @@ impl QueryPipeline {
     }
 
     /// Finds all handles of all the colliders with an [`Aabb`] intersecting the given [`Aabb`].
+    #[profiling::function]
     pub fn colliders_with_aabb_intersecting_aabb(
         &self,
         aabb: &Aabb,
@@ -604,6 +614,7 @@ impl QueryPipeline {
     ///   the shape is penetrating another shape at its starting point **and** its trajectory is such
     ///   that it’s on a path to exit that penetration state.
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn cast_shape(
         &self,
         bodies: &RigidBodySet,
@@ -645,6 +656,7 @@ impl QueryPipeline {
     ///    that normal) then the nonlinear shape-casting will attempt to find another impact,
     ///    at a time `> start_time` that could result in tunnelling.
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[profiling::function]
     pub fn nonlinear_cast_shape(
         &self,
         bodies: &RigidBodySet,
@@ -680,6 +692,7 @@ impl QueryPipeline {
     /// * `shape` - The shape to test.
     /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
     /// * `callback` - A function called with the handles of each collider intersecting the `shape`.
+    #[profiling::function]
     pub fn intersections_with_shape(
         &self,
         bodies: &RigidBodySet,